sorbet 0.5.5841

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b72f815f0182861350618922777098663e7c5815
+  data.tar.gz: 6de4663adb5d10acce279bd249fbcb208c60aeaf
+SHA512:
+  metadata.gz: fadbd2ab259b46e1481791454260ec447d38eb490766e7ae3c68b9845493e6799059e0605a0ae1c9b3ddcc0d086acabb1b808dde091f740401e6af2398abfc63
+  data.tar.gz: ebc49c3a2518b9de112670bb24989b544753e586bc7dbf74975e8a9b9becbb397318ecdb3afa90c0a006f042f6045ef665afe57c6589646b4760775b3fb377f6

data/bin/srb

@@ -0,0 +1,150 @@
+#!/usr/bin/env bash
+#!/usr/bin/env ruby
+
+# A total hack, but this file is both a valid ruby script and a bash script.
+=begin 2>/dev/null
+
+# From here on in, it is all bash until the last line
+
+help_and_exit() {
+  cat <<EOF
+A type checker for Ruby
+
+Usage:
+  srb                                 Same as "srb t"
+  srb (init | initialize)             Initializes the \`sorbet\` directory
+  srb rbi [options]                   Manage the \`sorbet\` directory
+  srb (t | tc | typecheck) [options]  Typechecks the code
+
+Options:
+  -h, --help     View help for this subcommand.
+  --version      Show version.
+
+For full help:
+  https://sorbet.org
+EOF
+  exit 0
+}
+
+subcommand=$1
+shift
+
+# /path/to/gems/sorbet-0.0.1/bin/srb
+srb_path="${BASH_SOURCE[0]}"
+
+compute_md5() {
+  if command -v md5sum > /dev/null; then
+    md5sum "$1"
+  elif command -v md5 > /dev/null; then
+    md5 -r "$1"
+  else
+    # this is quite a bit slower
+    ruby -e 'require "digest"; puts Digest::MD5.hexdigest(File.read(ARGV[0]))' "$1"
+  fi
+}
+
+typecheck() {
+  args=("$@")
+  cache_dir="${XDG_CACHE_HOME:-$HOME/.cache}/sorbet/gem-rbis"
+
+  if [ -z "$SRB_SKIP_GEM_RBIS" ] && [ -f Gemfile.lock ]; then
+    [ -d "$cache_dir" ] || mkdir -p "$cache_dir"
+    cache_hash=$(compute_md5 Gemfile.lock | awk '{ print $1 }')
+    cache_file="${cache_dir}/${cache_hash}"
+    if [ ! -f "$cache_file" ]; then
+      $0 rbi find-gem-rbis > /dev/null
+    fi
+    args+=("@$cache_file")
+  fi
+
+  if [ -n "$SRB_SORBET_EXE" ]; then
+    # shellcheck disable=SC2086
+    "$SRB_SORBET_EXE" "${args[@]}"
+  else
+    # We're using bash string operations here to avoid forking.
+    # Using dirname / basename / etc. would mean ~15ms for each call.
+
+    # /path/to/gems/sorbet-0.0.1
+    without_bin_srb="${srb_path%/bin/srb}"
+    # -0.0.1
+    version_suffix="${without_bin_srb##*/sorbet}"
+    # /path/to/gems
+    gems_path="${without_bin_srb%/sorbet*}"
+
+    # /path/to/gems/sorbet-static-0.0.1-darwin-17/libexec/sorbet
+    # (assumes people only have one platform-depdendent gem installed per version)
+    guess_sorbet=("$gems_path/sorbet-static$version_suffix"*/libexec/sorbet)
+
+    if [[ -f "${guess_sorbet[0]}" ]]; then
+      sorbet="${guess_sorbet[0]}"
+    else
+      # 0.0.1
+      version="${version_suffix#-}"
+      # Resort to locating using the GEM_PATH, this takes ~200ms
+      sorbet="$(VISUAL=echo gem open sorbet-static -v "${version}")/libexec/sorbet"
+    fi
+
+    # if we still don't know the sorbet binary
+    # perhaps this is the java platform
+    if ! [[ -f "${sorbet}" ]]; then
+      if gem env platform | grep -q "java"; then
+        # certain platforms (i.e. java) include multiple binaries
+        # mac.sorbet & linux.sorbet -- since they can't use the host platform (i.e. darwin or linux)
+        # to collect the correct sorbet binary
+        case "$(uname -s)" in
+        Linux*)     prefix="linux.";;
+        Darwin*)    prefix="mac.";;
+        *)          prefix=""
+        esac
+
+        guess_sorbet=("$gems_path/sorbet-static$version_suffix"*/libexec/"${prefix}sorbet")
+        if [[ -f "${guess_sorbet[0]}" ]]; then
+          sorbet="${guess_sorbet[0]}"
+        fi
+
+      fi
+    fi
+
+    # shellcheck disable=SC2086
+    "${sorbet}" "${args[@]}"
+  fi
+}
+
+# Dynamically computing the path to the srb-rbi script lets this script work
+# the same way in local development and when packaged as a gem. Either:
+#
+# /path/to/gems/sorbet-0.0.1/bin/srb-rbi
+# path/to/bin/srb-rbi
+srb_rbi_path="$srb_path-rbi"
+
+case $subcommand in
+  "initialize" | "init")
+    "$srb_rbi_path" "init"
+    ;;
+
+  "rbi")
+    "$srb_rbi_path" "$@"
+    ;;
+
+  "" | "typecheck" | "tc" | "t")
+    if [ ! -d sorbet ] && [ "$#" -eq 0 ]; then
+        echo "No sorbet/ directory found. Maybe you want to run 'srb init'?"
+        echo
+        help_and_exit
+    fi
+    typecheck "$@"
+    ;;
+
+  "--version")
+    typecheck --version
+    ;;
+
+  *)
+    echo "Unknown subcommand \`$subcommand\`"
+    help_and_exit
+esac
+
+exit $?
+# The closing comment for ruby to be ok with this file
+=end
+exec(__FILE__, *ARGV)

data/bin/srb-rbi

@@ -0,0 +1,237 @@
+#!/usr/bin/env ruby
+
+class Sorbet; end
+module Sorbet::Private; end
+
+require_relative '../lib/t'
+require_relative '../lib/step_interface'
+require_relative '../lib/create-config'
+require_relative '../lib/gem-generator-tracepoint'
+require_relative '../lib/hidden-definition-finder'
+require_relative '../lib/fetch-rbis'
+require_relative '../lib/find-gem-rbis'
+require_relative '../lib/suggest-typed'
+require_relative '../lib/todo-rbi'
+
+module Sorbet::Private::Main
+  def self.usage
+    "Usage: srb rbi <command>
+    This script gets your current directory ready for using Sorbet by making all sorts of files in ./sorbet/. You should commit them to version control.
+
+    We recommend running it without any options which will execute all the commands in order. If you only need a certain piece, you can pass a command to just run that part.
+
+    You should re-run this script if your program ever stops typechecking due to dynamic code in your project.
+
+    Common Commands:
+      help                Print this message
+      <empty> | update    Run all initialization commands
+
+    Specific Commands:
+      config              Recreate sorbet/config
+      sorbet-typed        Download community maintained type definitions for gems
+      gems                Generate arity-only type definitions by requiring the gem
+      hidden-definitions  Load all your code and generate type definitions for any dynamic code
+      todo                Run Sorbet and generate constants which Sorbet errors on
+      suggest-typed       Put the highest `typed:` sigil in each of your files
+      find-gem-rbis       Find all `rbi/` directories in your gems and list them in `~/.cache/sorbet`
+      "
+  end
+
+  def self.emojify(emoji, msg)
+    if STDOUT.isatty && RUBY_PLATFORM =~ /darwin/
+      "#{emoji} #{msg}"
+    else
+      msg
+    end
+  end
+
+  def self.yellow(msg)
+    if STDOUT.isatty
+      "\u001b[0;33m#{msg}\u001b[0m"
+    else
+      msg
+    end
+  end
+
+  def self.cyan(msg)
+    if STDOUT.isatty
+      "\u001b[0;36m#{msg}\u001b[0m"
+    else
+      msg
+    end
+  end
+
+  def self.init
+    puts "
+#{emojify("👋", "Hey there!")}
+
+This script will get this project ready to use with Sorbet by creating a
+sorbet/ folder for your project. It will contain:
+
+- a config file
+- a bunch of 'RBI files'
+
+RBI stands for 'Ruby Interface'; these files define classes, methods, and
+constants that exist, but which Sorbet doesn't always know about.
+
+#{emojify("⚠️ ", "Heads up:")}
+
+To set up your project, this script will take two potentially destructive
+actions:
+
+1.  It will #{yellow("require every file in your project")}. Specifically, every script in
+    your project will be run, unless that script checks #{cyan("if __FILE__ == $PROGRAM_NAME")}
+    before running any code, or has the magic comment #{cyan("# typed: ignore")} in it.
+
+2.  It will add a #{yellow("comment to the top of every file")} (like #{cyan("# typed: false")} or
+    #{cyan("# typed: true")}, depending on how many errors were found in that file.)
+
+"
+    if ENV['SRB_YES'] != nil
+      puts "SRB_YES set, continuing"
+    else
+      STDOUT.write(emojify("❔", "Would you like to continue? [Y/n] "))
+      if STDIN.isatty && STDOUT.isatty
+        begin
+          input = STDIN.gets&.strip
+          if input.nil? || (input != '' && input != 'y' && input != 'Y')
+            puts "\nAborting"
+            Kernel.exit(1)
+          end
+        rescue Interrupt
+          puts "\nAborting"
+          Kernel.exit(1)
+        end
+      else
+        puts "\nNot running interactivly. Set SRB_YES=1 environment variable to proceed"
+        Kernel.exit(1)
+      end
+    end
+
+    # Create sorbet/config file
+    make_step(Sorbet::Private::CreateConfig).call
+
+    # Pull in the hand-written RBIs
+    make_step(Sorbet::Private::FetchRBIs).call
+
+    # Generate the RBIs from bundler
+    make_step(Sorbet::Private::GemGeneratorTracepoint).call
+
+    # Find the hidden methods
+    make_step(Sorbet::Private::HiddenMethodFinder).call
+
+    # Run sorbet and make constants to fix errors
+    make_step(Sorbet::Private::TodoRBI).call
+
+    # Run type suggestion once, and then generate the todo.rbi again.
+    #
+    # The first time we suggest typed sigils, a few files may be ignored if they
+    # use Ruby features Sorbet does not support. However, since we ran the
+    # todo.rbi generation before they were ignored, we discovered the constants
+    # that they defined and did not add the constants to todo.rbi file.
+    #
+    # Regenerating after one run of sigil suggestion will put those constants
+    # into the todo.rbi file.
+    Sorbet::Private::SuggestTyped.suggest_typed
+    Sorbet::Private::TodoRBI.main
+
+    # Put some `typed:` sigils
+    make_step(Sorbet::Private::SuggestTyped).call
+
+    puts "
+#{emojify("✅", "Done!")}
+
+This project is now set up for use with Sorbet. The sorbet/ folder should exist
+and look something like this:
+
+    sorbet/
+    #{emojify("├──", " ")}config                      # Default options to be passed to sorbet on every run
+    #{emojify("└──", " ")}rbi/
+        #{emojify("├──", " ")}sorbet-typed/           # Community written type definition files for your gems
+        #{emojify("├──", " ")}gems/                   # Autogenerated type definitions for your gems (from reflection)
+        #{emojify("├──", " ")}hidden-definitions/     # All definitions that exist at runtime, but Sorbet couldn't see statically
+        #{emojify("└──", " ")}todo.rbi                # Constants which were still missing, even after the three steps above.
+
+Please check this whole folder into version control.
+
+#{emojify("➡️ ", "What's next?")}
+
+Up to you! First things first, you'll probably want to typecheck your project:
+
+    #{cyan("srb tc")}
+
+Other than that, it's up to you!
+We recommend skimming these docs to get a feel for how to use Sorbet:
+
+- Gradual Type Checking (#{cyan("https://sorbet.org/docs/gradual")})
+- Enabling Static Checks (#{cyan("https://sorbet.org/docs/static")})
+- RBI Files (#{cyan("https://sorbet.org/docs/rbi")})
+
+If instead you want to explore your files locally, here are some things to try:
+
+- Upgrade a file marked #{cyan("# typed: false")} to #{cyan("# typed: true")}.
+  Then, run #{cyan("srb tc")} and try to fix any errors.
+- Add signatures to your methods with `sig`.
+  For how, read: #{cyan("https://sorbet.org/docs/sigs")}
+- Check whether things that show up in the TODO RBI file actually exist in your project.
+  It's possible some of these constants are typos.
+- Upgrade a file marked #{cyan("# typed: ignore")} to #{cyan("# typed: false")}.
+  Then, run #{cyan("srb rbi hidden-definitions && srb tc")} and try to fix any errors.
+
+#{emojify("🙌", "Please don't hesitate to give us your feedback!")}
+    "
+  end
+
+  def self.main(argv)
+    if argv.length == 0
+      puts self.usage
+      exit(1)
+    end
+
+    command = case (argv[0])
+    when 'help', '--help'
+      puts self.usage
+      exit(1)
+    when 'init', 'update'
+      self.init
+      return
+    when 'config', Sorbet::Private::CreateConfig.output_file
+      make_step(Sorbet::Private::CreateConfig)
+    when 'sorbet-typed', Sorbet::Private::FetchRBIs.output_file, Sorbet::Private::FetchRBIs::SORBET_RBI_LIST
+      make_step(Sorbet::Private::FetchRBIs)
+    when 'gems', Sorbet::Private::GemGeneratorTracepoint.output_file
+      -> do
+        make_step(Sorbet::Private::GemGeneratorTracepoint).call
+        make_step(Sorbet::Private::SuggestTyped).call
+      end
+    when 'hidden-definitions', Sorbet::Private::HiddenMethodFinder.output_file
+      make_step(Sorbet::Private::HiddenMethodFinder)
+    when 'todo', Sorbet::Private::TodoRBI.output_file
+      make_step(Sorbet::Private::TodoRBI)
+    when 'suggest-typed'
+      make_step(Sorbet::Private::SuggestTyped)
+
+    when 'find-gem-rbis', "#{ENV['HOME']}/.cache/sorbet/gem-rbis", "#{ENV['HOME']}/.cache/sorbet/gem-rbis/"
+      make_step(Sorbet::Private::FindGemRBIs)
+
+    else
+      puts "Unknown command: #{argv[0]}"
+      puts self.usage
+      exit(1)
+    end
+
+    puts "Running command: #{argv[0]}"
+    command.call
+    nil
+  end
+
+  T::Sig::WithoutRuntime.sig {params(step: Sorbet::Private::StepInterface).returns(T.proc.void)}
+  def self.make_step(step)
+    -> do
+      puts "Generating: #{step.output_file}" if step.output_file
+      step.main
+    end
+  end
+end
+
+Sorbet::Private::Main.main(ARGV)

data/lib/constant_cache.rb

@@ -0,0 +1,226 @@
+# frozen_string_literal: true
+# typed: true
+
+require_relative './real_stdlib'
+require_relative './status'
+
+# This class walks global namespace to find all modules and discover all of their names.
+# At the time you ask for it it, it takes a "spashot" of the world.
+# If new modules were defined after an instance of this class was created,
+# they won't be visible through a previously returned instance.
+class Sorbet::Private::ConstantLookupCache
+
+  ConstantEntry = Struct.new(:const_name, :found_name, :primary_name, :aliases, :const, :owner)
+
+  # We won't be able to see if someone mankeypatches these.
+  DEPRECATED_CONSTANTS = [
+    '::Bignum',
+    '::Config',
+    '::Data',
+    '::FALSE',
+    '::Fixnum',
+    '::NIL',
+    '::TRUE',
+    '::TimeoutError',
+    'ERB::Compiler::SimpleScanner2',
+    'Net::OpenSSL',
+    'Object::Bignum',
+    'Object::Config',
+    'Object::Data',
+    'Object::FALSE',
+    'Object::Fixnum',
+    'Object::NIL',
+    'Object::TRUE',
+    'Object::TimeoutError',
+    'OpenSSL::Cipher::Cipher',
+    'OpenSSL::Cipher::Digest',
+    'OpenSSL::Digest::Cipher',
+    'OpenSSL::Digest::Digest',
+    'OpenSSL::SSL::SSLContext::METHODS',
+    'Pry::Platform',
+    'Pry::Prompt::MAP',
+    'Sequel::BeforeHookFailed',
+    'Sequel::Database::ResetIdentifierMangling',
+    'Sequel::Error::AdapterNotFound',
+    'Sequel::Error::InvalidOperation',
+    'Sequel::Error::InvalidValue',
+    'Sequel::Error::PoolTimeoutError',
+    'Sequel::Error::Rollback',
+    'Sequel::Model::ANONYMOUS_MODEL_CLASSES',
+    'Sequel::Model::ANONYMOUS_MODEL_CLASSES_MUTEX',
+    'Sequel::UnbindDuplicate',
+    'Sequel::Unbinder',
+    'YARD::Parser::Ruby::Legacy::RipperParser',
+    'Java::ComHeadiusRacc::Cparse::CparseParams::NEVER',
+    'Java::ComHeadiusRacc::Cparse::CparseParams::UNDEF',
+    'Java::ComHeadiusRacc::Cparse::Parser::NEVER',
+    'Java::ComHeadiusRacc::Cparse::Parser::UNDEF',
+    'Java::OrgJruby::RubyBasicObject::NEVER',
+    'Java::OrgJruby::RubyBasicObject::UNDEF',
+    'Java::OrgJruby::RubyClass::NEVER',
+    'Java::OrgJruby::RubyClass::UNDEF',
+    'Java::OrgJruby::RubyModule::NEVER',
+    'Java::OrgJruby::RubyModule::UNDEF',
+    'Java::OrgJruby::RubyObject::NEVER',
+    'Java::OrgJruby::RubyObject::UNDEF',
+  ].freeze
+
+  def initialize
+    @all_constants = {}
+    dfs_module(Object, nil, @all_constants, nil)
+    Sorbet::Private::Status.done
+    @consts_by_name = {}
+    @all_constants.each_value do |struct|
+      fill_primary_name(struct)
+      @consts_by_name[struct.primary_name] = struct.const
+    end
+  end
+
+  def all_module_names
+    ret = @all_constants.select {|_k, v| Sorbet::Private::RealStdlib.real_is_a?(v.const, Module)}.map do |_key, struct|
+      raise "should never happen" if !struct.primary_name
+      struct.primary_name
+    end
+    ret
+  end
+
+  def all_named_modules
+    ret = @all_constants.select {|_k, v| Sorbet::Private::RealStdlib.real_is_a?(v.const, Module)}.map do |_key, struct|
+      raise "should never happen" if !struct.primary_name
+      struct.const
+    end
+    ret
+  end
+
+  def all_module_aliases
+    ret = {}
+
+    @all_constants.map do |_key, struct|
+      next if struct.nil? || !Sorbet::Private::RealStdlib.real_is_a?(struct.const, Module) || struct.aliases.size < 2
+      if struct.owner != nil
+        ret[struct.primary_name] = struct.aliases.reject do |name|
+          # ignore the primary
+          next true if name == struct.primary_name
+
+          prefix, _, _ = name.rpartition('::')
+
+          # an alias that exists at the top-level
+          next false if prefix == ""
+
+          # if the prefix is the same syntactically, then this is a good alias
+          next false if prefix == struct.owner.primary_name
+
+          # skip the alias if the owner is the same
+          other_owner_const = Sorbet::Private::RealStdlib.real_const_get(Object, prefix, false)
+          struct.owner.const == other_owner_const
+        end
+      else
+        # top-level names
+        ret[struct.primary_name] = struct.aliases.reject {|name| name == struct.primary_name }
+      end
+    end
+    ret
+  end
+
+  def class_by_name(name)
+    @consts_by_name[name]
+  end
+
+  def name_by_class(klass)
+    @all_constants[Sorbet::Private::RealStdlib.real_object_id(klass)]&.primary_name
+  end
+
+  private def dfs_module(mod, prefix, ret, owner)
+    raise "error #{prefix}: #{mod} is not a module" if !Sorbet::Private::RealStdlib.real_is_a?(mod, Module)
+    name = Sorbet::Private::RealStdlib.real_name(mod)
+    Sorbet::Private::Status.say("Naming #{name}", print_without_tty: false)
+    return if name == 'RSpec::ExampleGroups' # These are all anonymous classes and will be quadratic in the number of classes to name them. We also know they don't have any hidden definitions
+    begin
+      constants = Sorbet::Private::RealStdlib.real_constants(mod)
+    rescue TypeError
+      puts "Failed to call `constants` on #{prefix}"
+      return nil
+    end
+    go_deeper = [] # make this a bfs to prefer shorter names
+    constants.each do |nested|
+      begin
+        next if Sorbet::Private::RealStdlib.real_autoload?(mod, nested) # some constants aren't autoloaded even after require_everything, e.g. StateMachine::Graph
+
+        begin
+          next if DEPRECATED_CONSTANTS.include?("#{prefix}::#{nested}") # avoid stdout spew
+        rescue NameError
+          # If it isn't to_s-able, that is ok, it won't be in our deprecated list
+          nil
+        end
+
+        begin
+          nested_constant = Sorbet::Private::RealStdlib.real_const_get(mod, nested, false) # rubocop:disable PrisonGuard/NoDynamicConstAccess
+        rescue LoadError => err
+          puts "Got #{err.class} when trying to get nested name #{name}::#{nested}"
+          next
+        rescue NameError, ArgumentError => err
+          puts "Got #{err.class} when trying to get nested name #{name}::#{nested}_"
+          # some stuff fails to load, like
+          # `const_get': uninitialized constant YARD::Parser::Ruby::Legacy::RipperParser (NameError)
+          # Did you mean?  YARD::Parser::Ruby::Legacy::RipperParser
+        end
+
+        object_id = Sorbet::Private::RealStdlib.real_object_id(nested_constant)
+        maybe_seen_already = ret[object_id]
+        if Object.eql?(mod) || !prefix
+          nested_name = nested.to_s
+        else
+          nested_name = prefix + "::" + nested.to_s
+        end
+        if maybe_seen_already
+          if nested_name != maybe_seen_already.primary_name
+            maybe_seen_already.aliases << nested_name
+            maybe_seen_already.owner = owner
+          end
+          if maybe_seen_already.primary_name.nil? && Sorbet::Private::RealStdlib.real_is_a?(nested_constant, Module)
+            realName = Sorbet::Private::RealStdlib.real_name(nested_constant)
+            maybe_seen_already.primary_name = realName
+          end
+        else
+          entry = ConstantEntry.new(nested, nested_name, nil, [nested_name], nested_constant, owner)
+          ret[object_id] = entry
+
+          if Sorbet::Private::RealStdlib.real_is_a?(nested_constant, Module) && Object != nested_constant
+            go_deeper << [entry, nested_constant, nested_name]
+          end
+        end
+
+      end
+    end
+
+    # Horrible horrible hack to get private constants that are `include`d.
+    # This doesn't recurse so you can't get private constants inside the private
+    # constants, but I really hope you don't need those...
+    Sorbet::Private::RealStdlib.real_ancestors(mod).each do |ancestor|
+      object_id = Sorbet::Private::RealStdlib.real_object_id(ancestor)
+      name = Sorbet::Private::RealStdlib.real_name(ancestor)
+      next unless name
+      next if ret[object_id]
+      prefix, _, const_name = name.rpartition('::')
+      entry = ConstantEntry.new(const_name.to_sym, name, name, [name], ancestor, nil)
+      ret[object_id] = entry
+    end
+    sorted_deeper = go_deeper.sort_by do |entry, nested_constant, nested_name|
+      Sorbet::Private::RealStdlib.real_name(nested_constant)
+    end
+    sorted_deeper.each do |entry, nested_constant, nested_name|
+      dfs_module(nested_constant, nested_name, ret, entry)
+    end
+    nil
+  end
+
+  private def fill_primary_name(struct)
+    return if struct.primary_name
+    if !struct.owner
+      struct.primary_name = struct.found_name
+    else
+      fill_primary_name(struct.owner)
+      struct.primary_name = struct.owner.primary_name + "::" + struct.const_name.to_s
+    end
+  end
+end