sorbet 0.4.4250 → 0.4.4253

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA256:
-  metadata.gz: 488651a8c09596441a817bbc49958ea158308fb028e5e96af6c8d2671625dd23
-  data.tar.gz: 6603a05ec2eeb1f5d90c8c0627caf5dcb254947f32b8421bdec2cc6cd81e6458
+SHA1:
+  metadata.gz: 4a5b41ca48527927442222de4701655747e785db
+  data.tar.gz: 3f85bed09a6177796913319e2d6742a61cbb0b4d
 SHA512:
-  metadata.gz: 93874fba0b23854f5d6daca67017208aa9bfcfb02b79123e9a8b2f4a88371a34b4e68370976585c0440d4fe194dd1e50bc916b8f3b2bd960834beb5ac5eee5d7
-  data.tar.gz: a856dab916f3d965a80eb27b579ef9ad3a42f0caa01492b6312dbfe4a83b3aa42c4a1ee53ae0d2380a5b50fe269163e27b7e1a57d3658e9ef825ada0635316b5
+  metadata.gz: 38f9dd516cea9f1a20448972395c6f19bc27b14fc9c2629631bfc99d587f11d8567663f0b2b41bfefba2c8e06ec26830d54a5e370c04771863ab99300e965582
+  data.tar.gz: d457e3ba50b5a6d75813cfa0ac2803e05ffe322576a48e211b7b35dfb3a3d78a042d5dec01755b8a4f8af2638cd9034afce85eb641c32cf0ba050ba634cc7ed2

data/bin/srb

@@ -0,0 +1,117 @@
+#!/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"
+  else
+    md5 -r "$1"
+  fi
+}
+
+typecheck() {
+  args=""
+  cache_dir="${XDG_CACHE_HOME:-$HOME/.cache}/sorbet/gem-rbis"
+
+  if [ -f Gemfile.lock ]; then
+    [ -d "$cache_dir" ] || mkdir "$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
+  args="$args$@"
+
+  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)
+    sorbet=("$gems_path/sorbet-static$version_suffix"*/libexec/sorbet)
+
+    # shellcheck disable=SC2086
+    "${sorbet[0]}" $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"
+    ;;
+
+  "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,232 @@
+#!/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.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.main(argv)
+    command = parse_command(argv)
+    return command.call if command
+
+    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 = Kernel.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 passed to sorbet on every run
+    #{emojify("└──", " ")}rbi/
+        #{emojify("├──", " ")}sorbet-typed/           # Community writen 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 # typed: false to # 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 tc")} and try to fix any errors.
+
+#{emojify("🙌", "Please don't hesitate to give us your feedback!")}
+    "
+  end
+
+  def self.parse_command(argv)
+    return nil if argv.length == 0
+
+    banner = "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."
+    commands = "
+  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/` direcotries in your gems and list them in `~/.cache/sorbet`
+    "
+
+    command = case (argv[0])
+    when 'help', '--help'
+      puts banner
+      puts commands
+      exit(1)
+    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
+      make_step(Sorbet::Private::GemGeneratorTracepoint)
+    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)
+
+    when 'update'
+      nil
+
+    else
+      puts "Unknown comand: #{argv[0]}"
+      puts commands
+      exit(1)
+    end
+
+    puts "Running command: #{argv[0]}"
+    command
+  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,193 @@
+# 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',
+  ].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
+      ret[struct.primary_name] = struct.aliases.reject {|name| name == struct.primary_name}
+    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
+          puts "Failed to load #{name}::#{nested}"
+          next
+        rescue NameError, ArgumentError
+          puts "Failed to load #{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
+          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