sorbet-runtime 0.0.1.pre.prealpha → 0.4.4253

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA256:
-  metadata.gz: c4f49cb714c88c903514f17f163768e3bd1575acd6b0d03db35f75da70e16c1e
-  data.tar.gz: 79d77212df76f815de71d6ece2887942d115944b70837bd292726091d43eec83
+SHA1:
+  metadata.gz: de11dcda7e38c4977b8e8adb679d16e2e34b94df
+  data.tar.gz: 930cdf2804d7b8919dea38ccd474e261a654e03d
 SHA512:
-  metadata.gz: 0d4f30e545125cbb41591bb593ceb96460a8fb67deeafa2c9f37d7ec314998c53e26afa21c0af280633840a37ef1a06068c83f12cf330a24ef2bdb0a567dc024
-  data.tar.gz: be94a5f46d1e95b4ce2f8d767587e84271111bc026706210806349afab18fc327a2acd65295a85098241f13f3c313665b79da3cff0ac4efabeea9178f60f3df4
+  metadata.gz: 77caf2c55b6c999939a4860e8be38088854a4530cac75bee1c9cca68ed2d8b8c9ef6182061a15c73d0e5cf343ef6e2caaa7f3e5c45690b79ed41af18ebe1d2b4
+  data.tar.gz: 76a0990ca32cd691b58ae71ff7a34e6e63f0c674da3945718d6a5060f91bc08e50ec55972aafb8cf87930fba2220da3a336b557c8ad9121475e0a97445539a78

data/lib/sorbet-runtime.rb

@@ -0,0 +1,100 @@
+# 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/error_handler'
+require_relative 'types/private/runtime_levels'
+require_relative 'types/private/methods/_methods'
+require_relative 'types/sig'
+require_relative 'types/helpers'
+
+# 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/self_type'
+require_relative 'types/types/simple'
+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/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/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'
+# Props that run sigs statically so have to be after all the others :(
+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/serializable'
+require_relative 'types/props/type_validation'
+require_relative 'types/struct'
+
+require_relative 'types/compatibility_patches'

data/lib/types/_types.rb

@@ -0,0 +1,245 @@
+# 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 http://go/types.
+#
+# 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.new
+  end
+
+  # Indicates a function never returns (e.g. "Kernel#raise")
+  def self.noreturn
+    T::Types::NoReturn.new
+  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.new
+  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 is just equivalent to assignment, but this 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.
+  def self.type_alias(type)
+    T::Utils.coerce(type)
+  end
+
+  # References a type paramater 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), msg: T.nilable(String)).returns(A)}
+  def self.must(arg, msg=nil)
+    begin
+      if msg
+        if !T.unsafe(msg).is_a?(String)
+          raise TypeError.new("T.must expects a string as second argument")
+        end
+      else
+        msg = "Passed `nil` into T.must"
+      end
+      raise TypeError.new(msg) if arg.nil?
+      arg
+    rescue TypeError => e # raise into rescue to ensure e.backtrace is populated
+      T::Private::ErrorHandler.handle_inline_type_error(e)
+      arg
+    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
+
+  ### Generic classes ###
+
+  module Array
+    def self.[](type)
+      T::Types::TypedArray.new(type)
+    end
+  end
+
+  module Hash
+    def self.[](keys, values)
+      T::Types::TypedHash.new(keys: keys, values: values)
+    end
+  end
+
+  module Enumerable
+    def self.[](type)
+      T::Types::TypedEnumerable.new(type)
+    end
+  end
+
+  module Enumerator
+    def self.[](type)
+      T::Types::TypedEnumerator.new(type)
+    end
+  end
+
+  module Range
+    def self.[](type)
+      T::Types::TypedRange.new(type)
+    end
+  end
+
+  module Set
+    def self.[](type)
+      T::Types::TypedSet.new(type)
+    end
+  end
+
+  # When mixed into a module, indicates that Sorbet may export the CFG for methods in that module
+  module CFGExport; 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

data/lib/types/boolean.rb

@@ -0,0 +1,8 @@
+# typed: true
+# frozen_string_literal: true
+
+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))
+end

data/lib/types/compatibility_patches.rb

@@ -0,0 +1,37 @@
+# typed: ignore
+
+require_relative 'private/methods/_methods'
+
+# Work around an interaction bug with sorbet-runtime and rspec-mocks,
+# which occurs when using *_any_instance_of and and_call_original.
+#
+# When a sig is defined, sorbet-runtime will replace the sigged method
+# with a wrapper that, upon first invocation, re-wraps the method with a faster
+# implementation.
+#
+# When expect_any_instance_of is used, rspec stores a reference to the first wrapper,
+# to be restored later.
+#
+# The first wrapper is invoked as part of the test and sorbet-runtime replaces
+# the method definition with the second wrapper.
+#
+# But when mocks are cleaned up, rspec restores back to the first wrapper.
+# Upon subsequent invocations, the first wrapper is called, and sorbet-runtime
+# throws a runtime error, since this is an unexpected state.
+#
+# We work around this by forcing re-wrapping before rspec stores a reference
+# to the method.
+if defined? ::RSpec::Mocks::AnyInstance
+  module T
+    module CompatibilityPatches
+      module RecorderExtensions
+        def observe!(method_name)
+          method = @klass.instance_method(method_name.to_sym)
+          T::Private::Methods.maybe_run_sig_block_for_method(method)
+          super(method_name)
+        end
+      end
+      ::RSpec::Mocks::AnyInstance::Recorder.prepend(RecorderExtensions)
+    end
+  end
+end