sorbet 0.5.5841

data/lib/real_stdlib.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+# typed: true
+
+module Sorbet::Private::RealStdlib
+  def self.real_is_a?(o, klass)
+    @real_is_a ||= Object.instance_method(:is_a?)
+    @real_is_a.bind(o).call(klass)
+  end
+
+  def self.real_constants(mod)
+    @real_constants ||= Module.instance_method(:constants)
+    @real_constants.bind(mod).call(false)
+  end
+
+  def self.real_object_id(o)
+    @real_object_id ||= Object.instance_method(:object_id)
+    @real_object_id.bind(o).call
+  end
+
+  def self.real_name(o)
+    @real_name ||= Module.instance_method(:name)
+    @real_name.bind(o).call
+  end
+
+  def self.real_ancestors(mod)
+    @real_ancestors ||= Module.instance_method(:ancestors)
+    @real_ancestors.bind(mod).call
+  end
+
+  def self.real_instance_methods(mod, arg)
+    @real_instance_methods ||= Module.instance_method(:instance_methods)
+    @real_instance_methods.bind(mod).call(arg)
+  end
+
+  def self.real_singleton_methods(mod, arg)
+    @real_singleton_methods ||= Module.instance_method(:singleton_methods)
+    @real_singleton_methods.bind(mod).call(arg)
+  end
+
+  def self.real_private_instance_methods(mod, arg)
+    @real_private_instance_methods ||= Module.instance_method(:private_instance_methods)
+    @real_private_instance_methods.bind(mod).call(arg)
+  end
+
+  def self.real_singleton_class(obj)
+    @real_singleton_class ||= Object.instance_method(:singleton_class)
+    @real_singleton_class.bind(obj).call
+  end
+
+  def self.real_spaceship(obj, arg)
+    @real_spaceship ||= Object.instance_method(:<=>)
+    @real_spaceship.bind(obj).call(arg)
+  end
+
+  def self.real_hash(o)
+    @real_hash ||= Object.instance_method(:hash)
+    @real_hash.bind(o).call
+  end
+
+  def self.real_superclass(o)
+    @real_superclass ||= Class.instance_method(:superclass)
+    @real_superclass.bind(o).call
+  end
+
+  def self.real_eqeq(obj, other)
+    @real_eqeq ||= Object.instance_method(:==)
+    @real_eqeq.bind(obj).call(other)
+  end
+
+  def self.real_autoload?(o, klass)
+    @real_autoload ||= Object.instance_method(:autoload?)
+    @real_autoload.bind(o).call(klass)
+  end
+
+  def self.real_const_get(obj, const, arg)
+    @real_const_get ||= Object.singleton_class.instance_method(:const_get)
+    @real_const_get.bind(obj).call(const, arg)
+  end
+
+  def self.real_method(obj, sym)
+    @real_method ||= Object.instance_method(:method)
+    @real_method.bind(obj).call(sym)
+  end
+end

data/lib/require_everything.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+# typed: true
+
+require 'pathname'
+
+require_relative './gem_loader'
+require_relative './status'
+
+class ExitCalledError < RuntimeError
+end
+
+class Sorbet::Private::RequireEverything
+  # Goes through the most common ways to require all your userland code
+  def self.require_everything
+    return if @already_ran
+    @already_ran = true
+    patch_kernel
+    load_rails
+    load_bundler # this comes second since some rails projects fail `Bundler.require' before rails is loaded
+    require_all_files
+  end
+
+  def self.load_rails
+    return unless rails?
+    require './config/application'
+    rails = Object.const_get(:Rails)
+    rails.application.require_environment!
+    rails.application.eager_load!
+    true
+  end
+
+  def self.load_bundler
+    return unless File.exist?('Gemfile')
+    begin
+      require 'bundler'
+    rescue LoadError
+      return
+    end
+    Sorbet::Private::GemLoader.require_all_gems
+  end
+
+  def self.require_all_files
+    excluded_paths = Set.new
+    excluded_paths += excluded_rails_files if rails?
+
+    abs_paths = rb_file_paths
+    errors = []
+    abs_paths.each_with_index do |abs_path, i|
+      # Executable files are likely not meant to be required.
+      # Some things we're trying to prevent against:
+      # - misbehaving require-time side effects (removing files, reading from stdin, etc.)
+      # - extra long runtime (making network requests, running a benchmark)
+      # While this isn't a perfect heuristic for these things, it's pretty good.
+      next if File.executable?(abs_path)
+      next if excluded_paths.include?(abs_path)
+
+      # Skip db/schema.rb, as requiring it can wipe the database. This is left
+      # out of exclude_rails_files, as it is possible to use the packages that
+      # generate it without using the whole rails ecosystem.
+      next if /db\/schema.rb$/.match(abs_path)
+
+      # Skip **/extconf.rb, as running it will emit build configuration artifacts
+      next if /\/extconf.rb$/.match(abs_path)
+
+      begin
+        my_require(abs_path, i+1, abs_paths.size)
+      rescue LoadError, NoMethodError, SyntaxError
+        next
+      rescue
+        errors << abs_path
+        next
+      end
+    end
+    # one more chance for order dependent things
+    errors.each_with_index do |abs_path, i|
+      begin
+        my_require(abs_path, i+1, errors.size)
+      rescue
+      end
+    end
+
+    Sorbet::Private::Status.done
+  end
+
+  def self.my_require(abs_path, numerator, denominator)
+    rel_path = Pathname.new(abs_path).relative_path_from(Pathname.new(Dir.pwd)).to_s
+    Sorbet::Private::Status.say("[#{numerator}/#{denominator}] require_relative './#{rel_path}'")
+    require_relative abs_path
+  end
+
+  def self.patch_kernel
+    Kernel.send(:define_method, :exit) do |*|
+      puts 'Kernel#exit was called while requiring ruby source files'
+      raise ExitCalledError.new
+    end
+
+    Kernel.send(:define_method, :at_exit) do |&block|
+      if File.split($0).last == 'rake'
+        # Let `rake test` work
+        super
+        return proc {}
+      end
+      # puts "Ignoring at_exit: #{block}"
+      proc {}
+    end
+  end
+
+  private
+
+  def self.rb_file_paths
+    srb = File.realpath("#{__dir__}/../bin/srb")
+    output = IO.popen([
+      srb,
+      "tc",
+      "-p",
+      "file-table-json",
+      "--stop-after=parser",
+      "--silence-dev-message",
+      "--no-error-count",
+      "-e",
+      "''",
+    ]) {|io| io.read}
+    # This returns a hash with structure:
+    # { files:
+    #   [
+    #     {
+    #       "strict": ["Ignore"|"False"|"True"|"Strict"|"Strong"|"Stdlib"],
+    #       "path": "./path/to/file",
+    #       ...
+    #     }
+    #     ...
+    #   ]
+    # }
+    parsed = JSON.parse(output)
+    parsed
+      .fetch('files', [])
+      .reject{|file| ["Ignore", "Stdlib"].include?(file["strict"])}
+      .map{|file| file["path"]}
+      .select{|path| File.file?(path)} # Some files have https:// paths. We ignore those here.
+      .select{|path| /.rb$/.match(path)}
+      .map{|path| File.expand_path(path)} # Requires absolute path
+  end
+
+  def self.excluded_rails_files
+    excluded_paths = Set.new
+
+    # Exclude files that have already been loaded by rails
+    self.rails_load_paths.each do |path|
+      excluded_paths += Dir.glob("#{path}/**/*.rb")
+    end
+
+    # Exclude initializers, as they have already been run by rails and
+    # can contain side-effects like monkey-patching that should
+    # only be run once.
+    excluded_paths += Dir.glob("#{Dir.pwd}/config/initializers/**/*.rb")
+  end
+
+  def self.rails_load_paths
+    rails = Object.const_get(:Rails)
+
+    # As per changes made to change the arity of this method:
+    # https://github.com/rails/rails/commit/b6e17b6a4b67ccc9fac5fe16741c3db720f00959
+    # This sets the `add_autoload_paths_to_load_path` parameter to `true` which will
+    # provide parity with older versions of Rails prior to the mentioned commit.
+    if Gem::Version.new(rails.version) >= Gem::Version.new('6.0.0.rc2')
+      rails.application.send(:_all_load_paths, true)
+    else
+      rails.application.send(:_all_load_paths)
+    end
+  end
+
+  def self.rails?
+    return false unless File.exist?('config/application.rb')
+    begin
+      require 'rails'
+    rescue LoadError
+      return false
+    end
+    true
+  end
+end

data/lib/serialize.rb

@@ -0,0 +1,362 @@
+# frozen_string_literal: true
+# typed: true
+
+require 'bigdecimal'
+
+class Sorbet::Private::Serialize
+  BLACKLIST_CONSTANTS = [
+    ['DidYouMean', :NameErrorCheckers], # https://github.com/yuki24/did_you_mean/commit/b72fdbe194401f1be21f8ad7b6e3f784a0ad197d
+    ['Net', :OpenSSL], # https://github.com/yuki24/did_you_mean/commit/b72fdbe194401f1be21f8ad7b6e3f784a0ad197d
+  ]
+
+  SPECIAL_METHOD_NAMES = %w[! ~ +@ ** -@ * / % + - << >> & | ^ < <= => > >= == === != =~ !~ <=> [] []= `]
+
+  def initialize(constant_cache)
+    @constant_cache = constant_cache
+  end
+
+  private def get_constants(mod, inherited=nil)
+    @real_constants ||= Module.instance_method(:constants)
+    if inherited.nil?
+      @real_constants.bind(mod).call
+    else
+      @real_constants.bind(mod).call(inherited)
+    end
+  end
+
+  def self.header(typed="true", subcommand="update")
+    buffer = []
+    buffer << "# This file is autogenerated. Do not edit it by hand. Regenerate it with:"
+    buffer << "#   srb rbi #{subcommand}"
+    if typed
+      buffer << ""
+      buffer << "# typed: #{typed}"
+    end
+    buffer << ""
+    buffer.join("\n")
+  end
+
+  def class_or_module(class_name)
+    if !valid_class_name(class_name)
+      return " # Skipping serializing #{class_name} because it is an invalid name\n"
+    end
+
+    klass = @constant_cache.class_by_name(class_name)
+    is_nil = nil.equal?(klass)
+    raise "#{class_name} is not a Class or Module. Maybe it was miscategorized?" if is_nil
+
+    ret = String.new
+
+    superclass = Sorbet::Private::RealStdlib.real_is_a?(klass, Class) ? Sorbet::Private::RealStdlib.real_superclass(klass) : nil
+    if superclass
+      superclass_str = Sorbet::Private::RealStdlib.real_eqeq(superclass, Object) ? '' : @constant_cache.name_by_class(superclass)
+    else
+      superclass_str = ''
+    end
+    superclass_str = !superclass_str || superclass_str.empty? ? '' : " < #{superclass_str}"
+    ret << (Sorbet::Private::RealStdlib.real_is_a?(klass, Class) ? "class #{class_name}#{superclass_str}\n" : "module #{class_name}\n")
+
+    # We don't use .included_modules since that also has all the aweful things
+    # that are mixed into Object. This way we at least have a delimiter before
+    # the awefulness starts (the superclass).
+    Sorbet::Private::RealStdlib.real_ancestors(klass).each do |ancestor|
+      next if Sorbet::Private::RealStdlib.real_eqeq(ancestor, klass)
+      break if Sorbet::Private::RealStdlib.real_eqeq(ancestor, superclass)
+      ancestor_name = @constant_cache.name_by_class(ancestor)
+      next unless ancestor_name
+      next if ancestor_name == class_name
+      if Sorbet::Private::RealStdlib.real_is_a?(ancestor, Class)
+        ret << "  # Skipping `include #{ancestor_name}` because it is a Class\n"
+        next
+      end
+      if !valid_class_name(ancestor_name)
+        ret << "  # Skipping `include #{ancestor_name}` because it is an invalid name\n"
+        next
+      end
+      ret << "  include ::#{ancestor_name}\n"
+    end
+    singleton_class = Sorbet::Private::RealStdlib.real_singleton_class(klass)
+    Sorbet::Private::RealStdlib.real_ancestors(singleton_class).each do |ancestor|
+      next if ancestor == Sorbet::Private::RealStdlib.real_singleton_class(klass)
+      break if superclass && ancestor == Sorbet::Private::RealStdlib.real_singleton_class(superclass)
+      break if ancestor == Module
+      break if ancestor == Object
+      ancestor_name = @constant_cache.name_by_class(ancestor)
+      next unless ancestor_name
+      if Sorbet::Private::RealStdlib.real_is_a?(ancestor, Class)
+        ret << "  # Skipping `extend #{ancestor_name}` because it is a Class\n"
+        next
+      end
+      if !valid_class_name(ancestor_name)
+        ret << "  # Skipping `extend #{ancestor_name}` because it is an invalid name\n"
+        next
+      end
+      ret << "  extend ::#{ancestor_name}\n"
+    end
+
+    constants = []
+    # Declare all the type_members and type_templates
+    constants += get_constants(klass).uniq.map do |const_sym|
+      # We have to not pass `false` because `klass.constants` intentionally is
+      # pulling in all the ancestor constants
+      next if Sorbet::Private::ConstantLookupCache::DEPRECATED_CONSTANTS.include?("#{class_name}::#{const_sym}")
+      begin
+        value = klass.const_get(const_sym)
+      rescue LoadError, NameError, RuntimeError, ArgumentError => err
+        ret << "# Got #{err.class} when trying to get class constant symbol #{class_name}::#{const_sym}\n"
+        next
+      end
+      # next if !Sorbet::Private::RealStdlib.real_is_a?(value, T::Types::TypeVariable)
+      next if Sorbet::Private::RealStdlib.real_is_a?(value, Module)
+      next if !comparable?(value)
+      [const_sym, value]
+    end
+    constants += get_constants(klass, false).uniq.map do |const_sym|
+      next if BLACKLIST_CONSTANTS.include?([class_name, const_sym])
+      next if Sorbet::Private::ConstantLookupCache::DEPRECATED_CONSTANTS.include?("#{class_name}::#{const_sym}")
+      begin
+        value = klass.const_get(const_sym, false)
+      rescue LoadError, NameError, RuntimeError, ArgumentError => err
+        ret << "# Got #{err.class} when trying to get class constant symbol #{class_name}::#{const_sym}_\n"
+        next
+      end
+      next if Sorbet::Private::RealStdlib.real_is_a?(value, Module)
+      next if !comparable?(value)
+      [const_sym, value]
+    end
+    constants_sorted = constants.compact.sort_by do |const_sym, _value|
+      const_sym
+    end
+    constants_uniq = constants_sorted.uniq do |const_sym, _value|
+      const_sym.hash
+    end
+    constants_serialized = constants_uniq.map do |const_sym, value|
+      constant(const_sym, value)
+    end
+    ret << constants_serialized.join("\n")
+    ret << "\n\n" if !constants_serialized.empty?
+
+    methods = []
+    instance_methods = Sorbet::Private::RealStdlib.real_instance_methods(klass, false)
+    begin
+      initialize = klass.instance_method(:initialize)
+    rescue
+      initialize = nil
+    end
+    if initialize && initialize.owner == klass
+      # This method never apears in the reflection list...
+      instance_methods += [:initialize]
+    end
+    Sorbet::Private::RealStdlib.real_ancestors(klass).reject {|ancestor| @constant_cache.name_by_class(ancestor)}.each do |ancestor|
+      instance_methods += ancestor.instance_methods(false)
+    end
+
+    # uniq here is required because we populate additional methos from anonymous superclasses and there
+    # might be duplicates
+    methods += instance_methods.sort.uniq.map do |method_sym|
+      begin
+        method = klass.instance_method(method_sym)
+      rescue => e
+        ret << "# #{e}\n"
+        next
+      end
+      next if blacklisted_method(method)
+      next if ancestor_has_method(method, klass)
+      serialize_method(method)
+    end
+    # uniq is not required here, but added to be on the safe side
+    methods += Sorbet::Private::RealStdlib.real_singleton_methods(klass, false).sort.uniq.map do |method_sym|
+      begin
+        method = klass.singleton_method(method_sym)
+      rescue => e
+        ret << "# #{e}\n"
+        next
+      end
+      next if blacklisted_method(method)
+      next if ancestor_has_method(method, Sorbet::Private::RealStdlib.real_singleton_class(klass))
+      serialize_method(method, true)
+    end
+    ret << methods.join("\n")
+    ret << "end\n"
+
+    ret
+  end
+
+  def alias(base, other_name)
+    ret = String.new
+    ret << "#{other_name} = #{base}"
+    ret
+  end
+
+  def comparable?(value)
+    return false if Sorbet::Private::RealStdlib.real_is_a?(value, BigDecimal) && value.nan?
+    return false if Sorbet::Private::RealStdlib.real_is_a?(value, Float) && value.nan?
+    return false if Sorbet::Private::RealStdlib.real_is_a?(value, Complex)
+    true
+  end
+
+  def blacklisted_method(method)
+    method.name =~ /__validator__[0-9]{8}/ || method.name =~ /.*:.*/
+  end
+
+  def valid_method_name(name)
+    return true if SPECIAL_METHOD_NAMES.include?(name)
+    return false if name =~ /^\d/
+    name =~ /^[[:word:]]+[?!=]?$/
+  end
+
+  def ancestor_has_method(method, klass)
+    return false if !Sorbet::Private::RealStdlib.real_is_a?(klass, Class)
+    first_ancestor = klass.ancestors.find do |ancestor|
+      next if ancestor == klass
+      begin
+        ancestor.instance_method(method.name)
+      rescue NameError
+        nil
+      end
+    end
+    return false unless first_ancestor
+    first_ancestor.instance_method(method.name).parameters == method.parameters
+  end
+
+  def constant(const, value)
+    if KEYWORDS.include?(const.to_sym)
+      return "# Illegal constant name: #{const}"
+    end
+    if defined?(T::Types) && Sorbet::Private::RealStdlib.real_is_a?(value, T::Types::TypeMember)
+      value.variance == :invariant ? "  #{const} = type_member" : "  #{const} = type_member(#{value.variance.inspect})"
+    elsif defined?(T::Types) && Sorbet::Private::RealStdlib.real_is_a?(value, T::Types::TypeTemplate)
+      value.variance == :invariant ? "  #{const} = type_template" : "  #{const} = type_template(#{value.variance.inspect})"
+    else
+      "  #{const} = ::T.let(nil, ::T.untyped)"
+    end
+  end
+
+  def serialize_method(method, static=false, with_sig: true)
+    name = method.name.to_s
+    if !valid_method_name(name)
+      return "# Illegal method name: #{name}\n"
+    end
+    parameters = from_method(method)
+    # a hack for appeasing Sorbet in the presence of the Enumerable interface
+    if name == 'each' && !parameters.any? {|(kind, _)| kind == :block}
+      parameters.push([:block, "blk"])
+    end
+    ret = String.new
+    ret << serialize_sig(parameters) if with_sig
+    args = parameters.map do |(kind, param_name)|
+      to_sig(kind, param_name)
+    end.compact.join(', ')
+    ret << "  def #{static ? 'self.' : ''}#{name}(#{args}); end\n"
+    ret
+  end
+
+  def valid_class_name(name)
+    name.split("::").each do |piece|
+      return false if piece[0].upcase != piece[0]
+    end
+    return false if [
+      'Sorbet::Private::GemGeneratorTracepoint::Tracer::ClassOverride',
+      'Sorbet::Private::GemGeneratorTracepoint::Tracer::ModuleOverride',
+      'Sorbet::Private::GemGeneratorTracepoint::Tracer::ObjectOverride',
+    ].include?(name)
+    true
+  end
+
+  def serialize_sig(parameters)
+    ret = String.new
+    if !parameters.empty?
+      ret << "  sig do\n"
+      ret << "    params(\n"
+      parameters.each do |(_kind, name)|
+        ret << "      #{name}: ::T.untyped,\n"
+      end
+      ret << "    )\n"
+      ret << "    .returns(::T.untyped)\n"
+      ret << "  end\n"
+    else
+      ret << "  sig {returns(::T.untyped)}\n"
+    end
+    ret
+  end
+
+  # from https://docs.ruby-lang.org/en/2.4.0/keywords_rdoc.html
+  KEYWORDS = [
+    :__ENCODING__,
+    :__LINE__,
+    :__FILE__,
+    :BEGIN,
+    :END,
+    :alias,
+    :and,
+    :begin,
+    :break,
+    :case,
+    :class,
+    :def,
+    :defined?,
+    :do,
+    :else,
+    :elsif,
+    :end,
+    :ensure,
+    :false,
+    :for,
+    :if,
+    :in,
+    :module,
+    :next,
+    :nil,
+    :not,
+    :or,
+    :redo,
+    :rescue,
+    :retry,
+    :return,
+    :self,
+    :super,
+    :then,
+    :true,
+    :undef,
+    :unless,
+    :until,
+    :when,
+    :while,
+    :yield,
+  ]
+
+  def from_method(method)
+    uniq = 0
+    method.parameters.map.with_index do |(kind, name), index|
+      if !name
+        arg_name = method.name.to_s[0...-1]
+        if (!KEYWORDS.include?(arg_name.to_sym)) && method.name.to_s.end_with?('=') && arg_name =~ /\A[a-z_][a-z0-9A-Z_]*\Z/ && index == 0
+          name = arg_name
+        else
+          name = '_' + (uniq == 0 ? '' : uniq.to_s)
+          uniq += 1
+        end
+      end
+      [kind, name]
+    end
+  end
+
+  def to_sig(kind, name)
+    case kind
+    when :req
+      name.to_s
+    when :opt
+      "#{name}=T.unsafe(nil)"
+    when :rest
+      "*#{name}"
+    when :keyreq
+      "#{name}:"
+    when :key
+      "#{name}: T.unsafe(nil)"
+    when :keyrest
+      "**#{name}"
+    when :block
+      "&#{name}"
+    end
+  end
+end