steep-activesupport-4 1.9.3

data/lib/steep/ast/types/tuple.rb

@@ -0,0 +1,60 @@
+module Steep
+  module AST
+    module Types
+      class Tuple
+        attr_reader :types
+
+        def initialize(types:)
+          @types = types
+        end
+
+        def ==(other)
+          other.is_a?(Tuple) &&
+            other.types == types
+        end
+
+        def hash
+          self.class.hash ^ types.hash
+        end
+
+        alias eql? ==
+
+        def subst(s)
+          self.class.new(types: types.map {|ty| ty.subst(s) })
+        end
+
+        def to_s
+          "[#{types.join(", ")}]"
+        end
+
+        def free_variables()
+          @fvs ||= each_child.with_object(Set[]) do |type, set| #$ Set[variable]
+            set.merge(type.free_variables)
+          end
+        end
+
+        include Helper::ChildrenLevel
+
+        def each_child(&block)
+          if block
+            types.each(&block)
+          else
+            types.each
+          end
+        end
+
+        def map_type(&block)
+          Tuple.new(types: types.map(&block))
+        end
+
+        def level
+          [0] + level_of_children(types)
+        end
+
+        def with_location(new_location)
+          self.class.new(types: types)
+        end
+      end
+    end
+  end
+end

data/lib/steep/ast/types/union.rb

@@ -0,0 +1,97 @@
+module Steep
+  module AST
+    module Types
+      class Union
+        attr_reader :types
+
+        def initialize(types:)
+          @types = types
+        end
+
+        def self.build(types:)
+          return AST::Types::Bot.instance if types.empty?
+          if types.size == 1
+            return types.first || raise
+          end
+
+          types.flat_map do |type|
+            if type.is_a?(Union)
+              type.types
+            else
+              [type]
+            end
+          end.map do |type|
+            case type
+            when AST::Types::Any
+              return AST::Types::Any.instance()
+            when AST::Types::Top
+              return AST::Types::Top.instance
+            when AST::Types::Bot
+              nil
+            else
+              type
+            end
+          end.compact.uniq.yield_self do |tys|
+            case tys.size
+            when 0
+              AST::Types::Bot.instance
+            when 1
+              tys.first || raise
+            else
+              new(types: tys)
+            end
+          end
+        end
+
+        def ==(other)
+          other.is_a?(Union) &&
+            Set.new(other.types) == Set.new(types)
+        end
+
+        def hash
+          @hash ||= types.inject(self.class.hash) {|c, type| type.hash ^ c } #$ Integer
+        end
+
+        alias eql? ==
+
+        def subst(s)
+          self.class.build(types: types.map {|ty| ty.subst(s) })
+        end
+
+        def to_s
+          "(#{types.map(&:to_s).join(" | ")})"
+        end
+
+        def free_variables
+          @fvs ||= Set.new.tap do |set|
+            types.each do |type|
+              set.merge(type.free_variables)
+            end
+          end
+        end
+
+        def each_child(&block)
+          if block
+            types.each(&block)
+          else
+            types.each
+          end
+        end
+
+        def map_type(&block)
+          Union.build(types: types.map(&block))
+        end
+
+        include Helper::ChildrenLevel
+
+        def level
+          [0] + level_of_children(types)
+        end
+
+        def with_location(new_location)
+          self.class.new(types: types)
+        end
+      end
+    end
+  end
+end

data/lib/steep/ast/types/var.rb

@@ -0,0 +1,65 @@
+module Steep
+  module AST
+    module Types
+      class Var
+        attr_reader :name
+
+        def initialize(name:)
+          @name = name
+        end
+
+        def ==(other)
+          other.is_a?(Var) &&
+            other.name == name
+        end
+
+        def hash
+          self.class.hash ^ name.hash
+        end
+
+        alias eql? ==
+
+        def self.fresh_name(name)
+          @mutex ||= Thread::Mutex.new
+
+          @mutex.synchronize do
+            @max ||= 0
+            @max += 1
+
+            :"#{name}(#{@max})"
+          end
+        end
+
+        def self.fresh(name, location: nil)
+          new(name: fresh_name(name))
+        end
+
+        def to_s
+          name.to_s
+        end
+
+        def subst(s)
+          if s.key?(name)
+            s[name]
+          else
+            self
+          end
+        end
+
+        def free_variables()
+          @fvs ||= Set.new([name])
+        end
+
+        include Helper::NoChild
+
+        def level
+          [0]
+        end
+
+        def update(name: self.name)
+          self.class.new(name: name)
+        end
+      end
+    end
+  end
+end

data/lib/steep/ast/types/void.rb

@@ -0,0 +1,35 @@
+module Steep
+  module AST
+    module Types
+      class Void
+        extend SharedInstance
+        
+        def ==(other)
+          other.is_a?(Void)
+        end
+
+        def hash
+          self.class.hash
+        end
+
+        alias eql? ==
+
+        def subst(s)
+          self
+        end
+
+        def to_s
+          "void"
+        end
+
+        include Helper::NoFreeVariables
+
+        include Helper::NoChild
+
+        def level
+          [0]
+        end
+      end
+    end
+  end
+end

data/lib/steep/cli.rb

@@ -0,0 +1,401 @@
+require 'optparse'
+
+module Steep
+  class CLI
+    attr_reader :argv
+    attr_reader :stdout
+    attr_reader :stdin
+    attr_reader :stderr
+    attr_reader :command
+
+    def initialize(stdout:, stdin:, stderr:, argv:)
+      @stdout = stdout
+      @stdin = stdin
+      @stderr = stderr
+      @argv = argv
+    end
+
+    def self.available_commands
+      [:init, :check, :validate, :annotations, :version, :project, :watch, :langserver, :stats, :binstub, :checkfile]
+    end
+
+    def process_global_options
+      OptionParser.new do |opts|
+        opts.banner = <<~USAGE
+          Usage: steep [options]
+
+          available commands: #{CLI.available_commands.join(', ')}
+
+          Options:
+        USAGE
+
+        opts.on("--version") do
+          process_version
+          exit 0
+        end
+
+        handle_logging_options(opts)
+      end.order!(argv)
+
+      true
+    end
+
+    def setup_command
+      return false unless command = argv.shift&.to_sym
+      @command = command
+
+      if CLI.available_commands.include?(@command) || @command == :worker || @command == :vendor
+        true
+      else
+        stderr.puts "Unknown command: #{command}"
+        stderr.puts "  available commands: #{CLI.available_commands.join(', ')}"
+        false
+      end
+    end
+
+    def run
+      process_global_options or return 1
+      setup_command or return 1
+
+      __send__(:"process_#{command}")
+    end
+
+    def handle_logging_options(opts)
+      opts.on("--log-level=LEVEL", "Specify log level: debug, info, warn, error, fatal") do |level|
+        Steep.logger.level = level
+        Steep.ui_logger.level = level
+      end
+
+      opts.on("--log-output=PATH", "Print logs to given path") do |file|
+        Steep.log_output = file
+      end
+
+      opts.on("--verbose", "Set log level to debug") do
+        Steep.logger.level = Logger::DEBUG
+        Steep.ui_logger.level = Logger::DEBUG
+      end
+    end
+
+    def handle_jobs_option(option, opts)
+      opts.on("-j N", "--jobs=N", "Specify the number of type check workers (defaults: #{option.default_jobs_count})") do |count|
+        option.jobs_count = Integer(count) if Integer(count) > 0
+      end
+
+      opts.on("--steep-command=COMMAND", "Specify command to exec Steep CLI for worker (defaults: steep)") do |cmd|
+        option.steep_command = cmd
+      end
+    end
+
+    def setup_jobs_for_ci(jobs_option)
+      if ENV["CI"]
+        unless jobs_option.jobs_count
+          stderr.puts Rainbow("CI environment is detected but no `--jobs` option is given.").yellow
+          stderr.puts "  Using `[2, #{jobs_option.default_jobs_count} (# or processors)].min` to avoid hitting memory limit."
+          stderr.puts "  Specify `--jobs` option to increase the number of jobs."
+
+          jobs_option.jobs_count = [2, jobs_option.default_jobs_count].min
+        end
+      end
+    end
+
+    def process_init
+      Drivers::Init.new(stdout: stdout, stderr: stderr).tap do |command|
+        OptionParser.new do |opts|
+          opts.banner = "Usage: steep init [options]"
+
+          opts.on("--steepfile=PATH") {|path| command.steepfile = Pathname(path) }
+          opts.on("--force") { command.force_write = true }
+
+          handle_logging_options opts
+        end.parse!(argv)
+      end.run()
+    end
+
+    def process_check
+      Drivers::Check.new(stdout: stdout, stderr: stderr).tap do |command|
+        OptionParser.new do |opts|
+          opts.banner = "Usage: steep check [options] [sources]"
+
+          opts.on("--steepfile=PATH") {|path| command.steepfile = Pathname(path) }
+          opts.on("--with-expectations[=PATH]", "Type check with expectations saved in PATH (or steep_expectations.yml)") do |path|
+            command.with_expectations_path = Pathname(path || "steep_expectations.yml")
+          end
+          opts.on("--save-expectations[=PATH]", "Save expectations with current type check result to PATH (or steep_expectations.yml)") do |path|
+            command.save_expectations_path = Pathname(path || "steep_expectations.yml")
+          end
+          opts.on("--severity-level=LEVEL", /^error|warning|information|hint$/, "Specify the minimum diagnostic severity to be recognized as an error (defaults: warning): error, warning, information, or hint") do |level|
+            command.severity_level = level.to_sym
+          end
+
+          opts.on("--group=GROUP", "Specify target/group name to type check") do |arg|
+            # @type var arg: String
+            target, group = arg.split(".")
+            target or raise
+            case group
+            when "*"
+              command.active_group_names << [target.to_sym, true]
+            when nil
+              command.active_group_names << [target.to_sym, nil]
+            else
+              command.active_group_names << [target.to_sym, group.to_sym]
+            end
+          end
+
+          opts.on("--[no-]type-check", "Type check Ruby code") do |v|
+            command.type_check_code = v ? true : false
+          end
+
+          opts.on("--validate=OPTION", ["skip", "group", "project", "library"], "Validation levels of signatures (default: group, options: skip,group,project,library)") do |level|
+            case level
+            when "skip"
+              command.validate_group_signatures = false
+              command.validate_project_signatures = false
+              command.validate_library_signatures = false
+            when "group"
+              command.validate_group_signatures = true
+              command.validate_project_signatures = false
+              command.validate_library_signatures = false
+            when "project"
+              command.validate_group_signatures = true
+              command.validate_project_signatures = true
+              command.validate_library_signatures = false
+            when "library"
+              command.validate_group_signatures = true
+              command.validate_project_signatures = true
+              command.validate_library_signatures = true
+            end
+          end
+
+          handle_jobs_option command.jobs_option, opts
+          handle_logging_options opts
+        end.parse!(argv)
+
+        setup_jobs_for_ci(command.jobs_option)
+
+        command.command_line_patterns.push *argv
+      end.run
+    end
+
+    def process_checkfile
+      Drivers::Checkfile.new(stdout: stdout, stderr: stderr).tap do |command|
+        OptionParser.new do |opts|
+          opts.banner = "Usage: steep checkfile [options] [files]"
+
+          opts.on("--steepfile=PATH") {|path| command.steepfile = Pathname(path) }
+          opts.on("--all-rbs", "Type check all RBS files") { command.all_rbs = true }
+          opts.on("--all-ruby", "Type check all Ruby files") { command.all_ruby = true }
+          opts.on("--stdin", "Read files to type check from stdin") do
+            while line = stdin.gets()
+              object = JSON.parse(line, symbolize_names: true)
+              Steep.logger.info { "Loading content of `#{object[:path]}` from stdin: #{object[:content].lines[0].chomp}" }
+              command.stdin_input[Pathname(object[:path])] = object[:content]
+            end
+          end
+          handle_jobs_option command.jobs_option, opts
+          handle_logging_options opts
+        end.parse!(argv)
+
+        setup_jobs_for_ci(command.jobs_option)
+
+        command.command_line_args.push *argv
+      end.run
+    end
+
+    def process_stats
+      Drivers::Stats.new(stdout: stdout, stderr: stderr).tap do |command|
+        OptionParser.new do |opts|
+          opts.banner = "Usage: steep stats [options] [sources]"
+
+          opts.on("--steepfile=PATH") {|path| command.steepfile = Pathname(path) }
+          opts.on("--format=FORMAT", "Specify output format: csv, table") {|format| command.format = format }
+          handle_jobs_option command.jobs_option, opts
+          handle_logging_options opts
+        end.parse!(argv)
+
+        setup_jobs_for_ci(command.jobs_option)
+
+        command.command_line_patterns.push *argv
+      end.run
+    end
+
+    def process_validate
+      stderr.puts "`steep validate` is deprecated. Use `steep check` with `--validate` option instead."
+      1
+    end
+
+    def process_annotations
+      Drivers::Annotations.new(stdout: stdout, stderr: stderr).tap do |command|
+        OptionParser.new do |opts|
+          opts.banner = "Usage: steep annotations [options] [sources]"
+          handle_logging_options opts
+        end.parse!(argv)
+
+        command.command_line_patterns.push *argv
+      end.run
+    end
+
+    def process_project
+      Drivers::PrintProject.new(stdout: stdout, stderr: stderr).tap do |command|
+        OptionParser.new do |opts|
+          opts.banner = "Usage: steep project [options]"
+          opts.on("--steepfile=PATH") {|path| command.steepfile = Pathname(path) }
+          opts.on("--[no-]print-files", "Print files") {|v|
+            command.print_files = v ? true : false
+          }
+          handle_logging_options opts
+        end.parse!(argv)
+      end.run
+    end
+
+    def process_watch
+      Drivers::Watch.new(stdout: stdout, stderr: stderr).tap do |command|
+        OptionParser.new do |opts|
+          opts.banner = "Usage: steep watch [options] [dirs]"
+          opts.on("--severity-level=LEVEL", /^error|warning|information|hint$/, "Specify the minimum diagnostic severity to be recognized as an error (defaults: warning): error, warning, information, or hint") do |level|
+            # @type var level: String
+            command.severity_level = _ = level.to_sym
+          end
+          handle_jobs_option command.jobs_option, opts
+          handle_logging_options opts
+        end.parse!(argv)
+
+        setup_jobs_for_ci(command.jobs_option)
+
+        dirs = argv.map {|dir| Pathname(dir) }
+        command.dirs.push(*dirs)
+      end.run
+    end
+
+    def process_langserver
+      Drivers::Langserver.new(stdout: stdout, stderr: stderr, stdin: stdin).tap do |command|
+        OptionParser.new do |opts|
+          opts.on("--steepfile=PATH") {|path| command.steepfile = Pathname(path) }
+          handle_jobs_option command.jobs_option, opts
+          handle_logging_options opts
+        end.parse!(argv)
+      end.run
+    end
+
+    def process_vendor
+      Drivers::Vendor.new(stdout: stdout, stderr: stderr, stdin: stdin).tap do |command|
+        OptionParser.new do |opts|
+          opts.banner = "Usage: steep vendor [options] [dir]"
+          handle_logging_options opts
+
+          opts.on("--[no-]clean") do |v|
+            command.clean_before = v
+          end
+        end.parse!(argv)
+
+        command.vendor_dir = Pathname(argv[0] || "vendor/sigs")
+      end.run
+    end
+
+    def process_binstub
+      path = Pathname("bin/steep")
+      root_path = Pathname.pwd
+      force = false
+
+      OptionParser.new do |opts|
+        opts.banner = <<BANNER
+Usage: steep binstub [options]
+
+Generate a binstub to execute Steep with setting up Bundler and rbenv/rvm.
+Use the executable for LSP integration setup.
+
+Options:
+BANNER
+        handle_logging_options opts
+
+        opts.on("-o PATH", "--output=PATH", "The path of the executable file (defaults to `bin/steep`)") do |v|
+          path = Pathname(v)
+        end
+
+        opts.on("--root=PATH", "The repository root path (defaults to `.`)") do |v|
+          root_path = (Pathname.pwd + v).cleanpath
+        end
+
+        opts.on("--[no-]force", "Overwrite file (defaults to false)") do
+          force = true
+        end
+      end.parse!(argv)
+
+      binstub_path = (Pathname.pwd + path).cleanpath
+      bindir_path = binstub_path.parent
+
+      bindir_path.mkpath
+
+      gemfile_path =
+        if defined?(Bundler)
+          Bundler.default_gemfile.relative_path_from(bindir_path)
+        else
+          Pathname("../Gemfile")
+        end
+
+      if binstub_path.file?
+        if force
+          stdout.puts Rainbow("#{path} already exists. Overwriting...").yellow
+        else
+          stdout.puts Rainbow(''"⚠️ #{path} already exists. Bye! 👋").red
+          return 0
+        end
+      end
+
+      template = <<TEMPLATE
+#!/usr/bin/env bash
+
+BINSTUB_DIR=$(cd $(dirname $0); pwd)
+GEMFILE=$(readlink -f ${BINSTUB_DIR}/#{gemfile_path})
+ROOT_DIR=$(readlink -f ${BINSTUB_DIR}/#{root_path.relative_path_from(bindir_path)})
+
+STEEP="bundle exec --gemfile=${GEMFILE} steep"
+
+if type "rbenv" > /dev/null 2>&1; then
+  STEEP="rbenv exec ${STEEP}"
+else
+  if type "rvm" > /dev/null 2>&1; then
+    if [ -e ${ROOT_DIR}/.ruby-version ]; then
+      STEEP="rvm ${ROOT_DIR} do ${STEEP}"
+    fi
+  fi
+fi
+
+exec $STEEP $@
+TEMPLATE
+
+      binstub_path.write(template)
+      binstub_path.chmod(0755)
+
+      stdout.puts Rainbow("Successfully generated executable #{path} 🎉").blue
+
+      0
+    end
+
+    def process_version
+      stdout.puts Steep::VERSION
+      0
+    end
+
+    def process_worker
+      Drivers::Worker.new(stdout: stdout, stderr: stderr, stdin: stdin).tap do |command|
+        OptionParser.new do |opts|
+          opts.banner = "Usage: steep worker [options] [dir]"
+          handle_logging_options opts
+
+          opts.on("--interaction") { command.worker_type = :interaction }
+          opts.on("--typecheck") { command.worker_type = :typecheck }
+          opts.on("--steepfile=PATH") {|path| command.steepfile = Pathname(path) }
+          opts.on("--name=NAME") {|name| command.worker_name = name }
+          opts.on("--delay-shutdown") { command.delay_shutdown = true }
+          opts.on("--max-index=COUNT") {|count| command.max_index = Integer(count) }
+          opts.on("--index=INDEX") {|index| command.index = Integer(index) }
+        end.parse!(argv)
+
+        # Disable any `ui_logger` output in workers
+        Steep.ui_logger.level = :fatal
+
+        command.commandline_args.push(*argv)
+      end.run
+    end
+  end
+end

data/lib/steep/diagnostic/deprecated/else_on_exhaustive_case.rb

@@ -0,0 +1,20 @@
+Steep.logger.error "Diagnostic `Ruby::ElseOnExhaustiveCase` is deprecated. Use `Ruby::UnreachableBranch` instead."
+
+module Steep
+  module Diagnostic
+    module Ruby
+      class ElseOnExhaustiveCase < Base
+        attr_reader :type
+
+        def initialize(node:, type:)
+          super(node: node)
+          @type = type
+        end
+
+        def header_line
+          "The branch is unreachable because the condition is exhaustive"
+        end
+      end
+    end
+  end
+end

data/lib/steep/diagnostic/deprecated/unknown_constant_assigned.rb

@@ -0,0 +1,28 @@
+Steep.logger.error "Diagnostic `Ruby::UnknownConstantAssigned` is deprecated. Use `Ruby::UnknownConstant` instead."
+
+module Steep
+  module Diagnostic
+    module Ruby
+      class UnknownConstantAssigned < Base
+        attr_reader :context
+        attr_reader :name
+
+        def initialize(node:, context:, name:)
+          const = node.children[0]
+          loc = if const
+                  const.loc.expression.join(node.loc.name)
+                else
+                  node.loc.name
+                end
+          super(node: node, location: loc)
+          @context = context
+          @name = name
+        end
+
+        def header_line
+          "Cannot find the declaration of constant `#{name}`"
+        end
+      end
+    end
+  end
+end