steep-activesupport-4 1.9.3

data/bin/mem_graph.rb

@@ -0,0 +1,67 @@
+class MemGraph
+  attr_reader :edges
+
+  attr_reader :checked
+
+  attr_reader :generation
+
+  def initialize(generation)
+    @generation = generation
+    @edges = []
+    @checked = Set.new.compare_by_identity
+    @checked << self
+    @checked << edges
+    @checked << checked
+  end
+
+  IVARS = Object.instance_method(:instance_variables)
+  IVGET = Object.instance_method(:instance_variable_get)
+
+  def traverse(object)
+    return if checked.include?(object)
+    checked << object
+
+    case object
+    when Array
+      object.each do |value|
+        insert_edge(object, value)
+        traverse(value)
+      end
+    when Hash
+      object.each do |key, value|
+        insert_edge(object, key)
+        insert_edge(object, value)
+
+        traverse(key)
+        traverse(value)
+      end
+    else
+      IVARS.bind_call(object).each do |name|
+        if name.is_a?(Symbol)
+          value = IVGET.bind_call(object, name)
+          traverse(value)
+          insert_edge(object, value)
+        else
+          STDERR.puts "Unexpected instance variable name: #{name} in #{object.class}"
+        end
+      end
+    end
+  end
+
+  def insert_edge(source, dest)
+    case dest
+    when Integer, Symbol, nil, true, false, Float
+    else
+      edges << [
+        "#{source.class}(#{source.__id__})",
+        "#{dest.class}(#{dest.__id__})",
+      ]
+    end
+  end
+
+  def dot
+    "digraph G {\n" + edges.uniq.map do |source, dest|
+      "  #{source} -> #{dest};"
+    end.join("\n") + "}"
+  end
+end

data/bin/mem_prof.rb

@@ -0,0 +1,102 @@
+require "objspace"
+
+class MemProf
+  attr_reader :generation
+
+  def initialize
+  end
+
+  def self.trace(io: STDOUT, &block)
+    profiler = MemProf.new
+    profiler.start
+
+    begin
+      ret = yield
+    rescue
+      ObjectSpace.trace_object_allocations_stop
+      ObjectSpace.trace_object_allocations_clear
+      raise
+    end
+
+    allocated, retained, collected = profiler.stop
+
+    counts = {}
+    collected.each do |id, entry|
+      counts[entry] ||= 0
+      counts[entry] += 1
+    end
+
+    counts.keys.sort_by {|entry| -counts[entry] }.take(200).each do |entry|
+      count = counts.fetch(entry)
+      io.puts "#{entry[0]},#{entry[1]},#{entry[2]},#{count}"
+    end
+
+    STDERR.puts "Total allocated: #{allocated.size}"
+    STDERR.puts "Total retained: #{retained.size}"
+    STDERR.puts "Total collected: #{collected.size}"
+
+    ret
+  end
+
+  def start
+    GC.disable
+    3.times { GC.start }
+    GC.start
+
+    @generation = GC.count
+    ObjectSpace.trace_object_allocations_start
+  end
+
+  def stop
+    ObjectSpace.trace_object_allocations_stop
+
+    allocated = objects()
+    retained = {}
+
+    GC.enable
+    GC.start
+    GC.start
+    GC.start
+
+    ObjectSpace.each_object do |obj|
+      next unless ObjectSpace.allocation_generation(obj) == generation
+      if o = allocated[obj.__id__]
+        retained[obj.__id__] = o
+      end
+    end
+
+    # ObjectSpace.trace_object_allocations_clear
+
+    collected = {}
+    allocated.each do |id, state|
+      collected[id] = state unless retained.key?(id)
+    end
+
+    [allocated, retained, collected]
+  end
+
+  def objects(hash = {})
+    ObjectSpace.each_object do |obj|
+      next unless ObjectSpace.allocation_generation(obj) == generation
+
+      file = ObjectSpace.allocation_sourcefile(obj) || "(no name)"
+      line = ObjectSpace.allocation_sourceline(obj)
+      klass = object_class(obj)
+
+      hash[obj.__id__] = [file, line, klass]
+    end
+
+    hash
+  end
+
+  KERNEL_CLASS_METHOD = Kernel.instance_method(:class)
+  def object_class(obj)
+    klass = obj.class rescue nil
+
+    unless Class === klass
+      # attempt to determine the true Class when .class returns something other than a Class
+      klass = KERNEL_CLASS_METHOD.bind_call(obj)
+    end
+    klass
+  end
+end

data/bin/output_rebaseline.rb

@@ -0,0 +1,34 @@
+require "pathname"
+require "yaml"
+require "open3"
+require "tempfile"
+
+if ARGV.empty?
+  test_dirs = (Pathname(__dir__) + "../smoke").children
+else
+  test_dirs = ARGV.map {|p| Pathname.pwd + p }
+end
+
+failed_tests = []
+
+test_dirs.each do |dir|
+  puts "Rebaselining #{dir}..."
+
+  command = %w(steep check --save-expectations=test_expectations.yml)
+  puts "  command: #{command.join(" ")}"
+
+  output, status = Open3.capture2(*command, chdir: dir.to_s)
+
+  unless status.success?
+    puts "Error!!! 👺"
+    failed_tests << dir.basename
+  end
+end
+
+if failed_tests.empty?
+  puts "Successfully updated output expectations! 🤡"
+else
+  puts "Failed to update the following tests! 💀"
+  puts "  #{failed_tests.join(", ")}"
+  exit 1
+end

data/bin/output_test.rb

@@ -0,0 +1,60 @@
+require "pathname"
+require "yaml"
+require "open3"
+require "tempfile"
+require "optparse"
+
+OptionParser.new do |opts|
+  opts.on("--verbose", "-v") { @verbose = true }
+end.parse!(ARGV)
+
+if ARGV.empty?
+  test_dirs = (Pathname(__dir__) + "../smoke").children
+else
+  test_dirs = ARGV.map {|p| Pathname.pwd + p }
+end
+
+failed_tests = []
+
+ALLOW_FAILURE = ["diagnostics-ruby-unsat"]
+
+test_dirs.each do |dir|
+  puts "Running test #{dir}..."
+
+  unless (dir + "test_expectations.yml").file?
+    puts "Skipped ⛹️‍♀️"
+    next
+  end
+
+  command = %w(steep check --with-expectations=test_expectations.yml)
+  command << "-j2" if ENV["CI"]
+  puts "  command: #{command.join(" ")}"
+
+  output, status = Open3.capture2(*command, chdir: dir.to_s)
+
+  unless status.success?
+    unless ALLOW_FAILURE.include?(dir.basename.to_s)
+      failed_tests << dir.basename
+      puts "  Failed! 🤕"
+    else
+      puts "  Failed! 🤕 (ALLOW_FAILURE)"
+    end
+  else
+    puts "  Succeed! 👍"
+  end
+
+  if @verbose
+    puts "  Raw output:"
+    output.split(/\n/).each do |line|
+      puts "  > #{line.chomp}"
+    end
+  end
+end
+
+if failed_tests.empty?
+  puts "All tests ok! 👏"
+else
+  puts "Errors detected! 🤮"
+  puts "  #{failed_tests.join(", ")}"
+  exit 1
+end

data/bin/rbs

@@ -0,0 +1,20 @@
+#!/usr/bin/env bash
+
+BINSTUB_DIR=$(cd $(dirname $0); pwd)
+GEMFILE=$(readlink -f ${BINSTUB_DIR}/../gemfile_steep/Gemfile)
+COLLECTION=$(readlink -f ${BINSTUB_DIR}/../rbs_collection.steep.yaml)
+ROOT_DIR=$(readlink -f ${BINSTUB_DIR}/..)
+
+RBS="bundle exec --gemfile=${GEMFILE} rbs --collection=${COLLECTION}"
+
+if type "rbenv" > /dev/null 2>&1; then
+  RBS="rbenv exec ${RBS}"
+else
+  if type "rvm" > /dev/null 2>&1; then
+    if [ -e ${ROOT_DIR}/.ruby-version ]; then
+      RBS="rvm ${ROOT_DIR} do ${RBS}"
+    fi
+  fi
+fi
+
+exec $RBS $@

data/bin/rbs-inline

@@ -0,0 +1,19 @@
+#!/usr/bin/env bash
+
+BINSTUB_DIR=$(cd $(dirname $0); pwd)
+GEMFILE=$(readlink -f ${BINSTUB_DIR}/../gemfile_steep/Gemfile)
+ROOT_DIR=$(readlink -f ${BINSTUB_DIR}/..)
+
+RBSINLINE="bundle exec --gemfile=${GEMFILE} rbs-inline"
+
+if type "rbenv" > /dev/null 2>&1; then
+  RBSINLINE="rbenv exec ${RBSINLINE}"
+else
+  if type "rvm" > /dev/null 2>&1; then
+    if [ -e ${ROOT_DIR}/.ruby-version ]; then
+      RBS="rvm ${ROOT_DIR} do ${RBSINLINE}"
+    fi
+  fi
+fi
+
+exec $RBSINLINE $@

data/bin/setup

@@ -0,0 +1,9 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+bundle install --gemfile=gemfile_steep/Gemfile
+bin/rbs collection install

data/bin/stackprof_test.rb

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+
+require "stackprof"
+
+mode = (ENV["STEEP_STACKPROF_MODE"] || :cpu).to_sym
+out = ENV["STEEP_STACKPROF_OUT"] || "tmp/stackprof-#{mode}-test.dump"
+interval = ENV["STEEP_STACKPROF_INTERVAL"]&.to_i || 1000
+
+STDERR.puts "Running profiler: mode => #{mode}, out => #{out}"
+StackProf.run(mode: mode, out: out, raw: true, interval: interval) do
+  # 10.times do
+  #   1_000.times do
+  #     Array.new(1_000_000)
+  #   end
+  #   sleep 0.1
+  # end
+
+  sleep 5
+end

data/bin/steep

@@ -0,0 +1,19 @@
+#!/usr/bin/env bash
+
+BINSTUB_DIR=$(cd $(dirname $0); pwd)
+GEMFILE=$(readlink -f ${BINSTUB_DIR}/../gemfile_steep/Gemfile)
+ROOT_DIR=$(readlink -f ${BINSTUB_DIR}/..)
+
+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 $@

data/bin/steep-check.rb

@@ -0,0 +1,251 @@
+#!/usr/bin/env ruby
+
+require 'pathname'
+
+$LOAD_PATH << Pathname(__dir__) + "../lib"
+
+require 'steep'
+require "fileutils"
+require "optparse"
+
+puts <<MESSAGE
+This is a single-threaded and one-process type checker for profiling.
+It runs really slow because it's not parallelized, but it's easier to profiling and analyzing the result.
+
+$ bundle exec bin/steep-check --target=app
+$ bundle exec bin/steep-check --target=app files...
+
+MESSAGE
+
+steep_file_path = Pathname("Steepfile")
+target_name = nil #: Symbol?
+profile_mode = :none #: Symbol?
+
+OptionParser.new do |opts|
+  opts.on("--steepfile=FILE") do |file|
+    steep_file_path = Pathname(file)
+  end
+  opts.on("--target=TARGET") do |target|
+    target_name = target.to_sym
+  end
+  opts.on("--profile=MODE", "vernier, memory, stackprof, none, majo, memory2, dumpall") do |mode|
+    profile_mode = mode.to_sym
+  end
+end.parse!(ARGV)
+
+command_line_args = ARGV.dup
+
+class Command
+  include Steep
+
+  attr_reader :project, :target
+
+  def initialize(steep_file_path:, target_name:)
+    @project = Project.new(steepfile_path: steep_file_path).tap do |project|
+      Project::DSL.parse(project, steep_file_path.read, filename: steep_file_path.to_s)
+    end
+
+    if target_name
+      @target = project.targets.find { _1.name == target_name}
+    else
+      @target = project.targets[0]
+    end
+
+    unless target
+      raise "!! Cannot find a target with #{target_name}: targets=[#{project.targets.map(&:name).join(", ")}]"
+    end
+  end
+
+  def load_signatures()
+    file_loader = Steep::Services::FileLoader.new(base_dir: project.base_dir)
+
+    signature_files = {}
+    file_loader.each_path_in_patterns(target.signature_pattern) do |path|
+      signature_files[path] = path.read
+    end
+
+    target.options.load_collection_lock
+
+    signature_service = Steep::Project::Target.construct_env_loader(options: target.options, project: project).yield_self do |loader|
+      Steep::Services::SignatureService.load_from(loader)
+    end
+
+    env = signature_service.latest_env
+
+    new_decls = Set[]
+
+    signature_files.each do |path, content|
+      buffer = RBS::Buffer.new(name: path.to_s, content: content)
+      buffer, dirs, decls = RBS::Parser.parse_signature(buffer)
+      env.add_signature(buffer: buffer, directives: dirs, decls: decls)
+      new_decls.merge(decls)
+    end
+
+    env.resolve_type_names(only: new_decls)
+  end
+
+  def type_check_files(command_line_args, env)
+    file_loader = Steep::Services::FileLoader.new(base_dir: project.base_dir)
+
+    source_files = {}
+    file_loader.each_path_in_patterns(target.source_pattern, command_line_args) do |path|
+      source_files[path] = path.read
+    end
+
+    definition_builder = RBS::DefinitionBuilder.new(env: env)
+    factory = AST::Types::Factory.new(builder: definition_builder)
+    builder = Interface::Builder.new(factory)
+    subtyping = Subtyping::Check.new(builder: builder)
+
+    typings = {}
+
+    source_files.each do |path, content|
+      source = Source.parse(content, path: path, factory: factory)
+
+      self_type = AST::Builtin::Object.instance_type
+
+      annotations = source.annotations(block: source.node, factory: factory, context: nil)
+      resolver = RBS::Resolver::ConstantResolver.new(builder: factory.definition_builder)
+      const_env = TypeInference::ConstantEnv.new(factory: factory, context: nil, resolver: resolver)
+
+      type_env = TypeInference::TypeEnvBuilder.new(
+        TypeInference::TypeEnvBuilder::Command::ImportGlobalDeclarations.new(factory),
+        TypeInference::TypeEnvBuilder::Command::ImportInstanceVariableAnnotations.new(annotations),
+        TypeInference::TypeEnvBuilder::Command::ImportConstantAnnotations.new(annotations),
+        TypeInference::TypeEnvBuilder::Command::ImportLocalVariableAnnotations.new(annotations)
+      ).build(TypeInference::TypeEnv.new(const_env))
+
+      context = TypeInference::Context.new(
+        block_context: nil,
+        method_context: nil,
+        module_context: TypeInference::Context::ModuleContext.new(
+          instance_type: AST::Builtin::Object.instance_type,
+          module_type: AST::Builtin::Object.module_type,
+          implement_name: nil,
+          nesting: nil,
+          class_name: AST::Builtin::Object.module_name,
+          instance_definition: factory.definition_builder.build_instance(AST::Builtin::Object.module_name),
+          module_definition: factory.definition_builder.build_singleton(AST::Builtin::Object.module_name)
+        ),
+        break_context: nil,
+        self_type: self_type,
+        type_env: type_env,
+        call_context: TypeInference::MethodCall::TopLevelContext.new(),
+        variable_context: TypeInference::Context::TypeVariableContext.empty
+      )
+
+      typing = Typing.new(source: source, root_context: context, cursor: nil)
+      construction = TypeConstruction.new(checker: subtyping, source: source, annotations: annotations, context: context, typing: typing)
+
+      construction.synthesize(source.node)
+      typings[path] = typing
+    end
+
+    typings
+  end
+end
+
+command = Command.new(steep_file_path: Pathname.pwd + steep_file_path, target_name: target_name)
+
+puts ">> Loading RBS files..."
+env = command.load_signatures()
+
+puts ">> Type checking files with #{profile_mode}..."
+
+typings = nil
+
+GC.start(immediate_sweep: true, immediate_mark: true, full_mark: true)
+# GC.config[:rgengc_allow_major_gc] = false
+
+case profile_mode
+when :vernier
+  require "vernier"
+  out = Pathname.pwd + "tmp/typecheck-#{Process.pid}.vernier.json"
+  puts ">> Profiling with vernier: #{out}"
+  Vernier.profile(out: out.to_s) do
+    typings = command.type_check_files(command_line_args, env)
+  end
+
+when :memory
+  require 'memory_profiler'
+  out = Pathname.pwd + "tmp/typecheck-#{Process.pid}.memory.txt"
+  puts ">> Profiling with memory_profiler: #{out}"
+  classes = nil
+  report = MemoryProfiler.report(trace: classes) do
+    typings = command.type_check_files(command_line_args, env)
+  end
+  report.pretty_print(to_file: out, detailed_report: true, scale_bytes: true, retained_strings: false, allocated_strings: false)
+
+when :memory2
+  require_relative 'mem_prof'
+  out = Pathname.pwd + "tmp/typecheck-#{Process.pid}.memory2.csv"
+  puts ">> Profiling with mem_prof: #{out}"
+  generation = nil
+  out.open("w") do |io|
+    MemProf.trace(io: io) do
+      generation = GC.count
+      typings = command.type_check_files(command_line_args, env)
+    end
+  end
+
+  require_relative 'mem_graph'
+  graph = MemGraph.new(generation)
+  ObjectSpace.each_object do |obj|
+    if ObjectSpace.allocation_generation(obj) == generation
+      graph.traverse(obj)
+    end
+  end
+  (Pathname.pwd + "objects-#{Process.pid}.dot").write(graph.dot)
+
+when :stackprof
+  require "stackprof"
+  out = Pathname.pwd + "tmp/typecheck-#{Process.pid}.stackprof"
+  puts ">> Profiling with stackprof: #{out}"
+  StackProf.run(out: out, raw: true, interval: 1000) do
+    typings = command.type_check_files(command_line_args, env)
+  end
+
+when :majo
+  require "majo"
+  out = Pathname.pwd + "tmp/typecheck-#{Process.pid}.majo.csv"
+  puts ">> Profiling with majo: #{out}"
+
+  result = Majo.run do
+    typings = command.type_check_files(command_line_args, env)
+  end
+
+  out.open("w") do  |io|
+    result.report(out: io, formatter: :csv)
+  end
+
+when :dumpall
+  require "objspace"
+  out = Pathname.pwd + "tmp/dumpall-#{Process.pid}.json"
+  puts ">> Profiling with dumpall: #{out}"
+  ObjectSpace.trace_object_allocations_start
+  typings = command.type_check_files(command_line_args, env)
+  out.open('w+') do |io|
+    ObjectSpace.dump_all(output: io)
+  end
+
+when :none
+
+  pp rbs_method_types: ObjectSpace.each_object(RBS::MethodType).count
+  GC.start(immediate_sweep: true, immediate_mark: true, full_mark: true)
+
+  pp defs: ObjectSpace.each_object(RBS::AST::Members::MethodDefinition).count
+  pp aliases: ObjectSpace.each_object(RBS::AST::Members::Alias).count
+  pp attr_reader: ObjectSpace.each_object(RBS::AST::Members::AttrReader).count
+  pp attr_writer: ObjectSpace.each_object(RBS::AST::Members::AttrWriter).count
+  pp attr_accessor: ObjectSpace.each_object(RBS::AST::Members::AttrAccessor).count
+
+  Steep.measure("type check", level: :fatal) do
+    GC.disable
+    typings = command.type_check_files(command_line_args, env)
+
+    pp steep_method_types: ObjectSpace.each_object(Steep::Interface::MethodType).count, rbs_method_types: ObjectSpace.each_object(RBS::MethodType).count
+    pp any: ObjectSpace.each_object(Steep::AST::Types::Any).count, void: ObjectSpace.each_object(Steep::AST::Types::Void).count, self: ObjectSpace.each_object(Steep::AST::Types::Self).count
+  end
+end
+
+typings.size

data/bin/steep-prof

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+
+require "stackprof"
+
+mode = (ENV["STEEP_STACKPROF_MODE"] || :cpu).to_sym
+out = ENV["STEEP_STACKPROF_OUT"] || "tmp/stackprof-#{mode}-steep.dump"
+interval = ENV["STEEP_STACKPROF_INTERVAL"]&.to_i || 1000
+
+def exit(*)
+
+end
+
+STDERR.puts "Running profiler: mode=#{mode}, out=#{out}"
+StackProf.run(mode: mode, out: out, raw: true, interval: interval) do
+  load File.join(__dir__, "../exe/steep")
+end