steep-relaxed 1.9.3.3

data/bin/generate-diagnostics-docs.rb

@@ -0,0 +1,112 @@
+# rbs_inline: enabled
+
+require "rbs"
+require "steep"
+
+class RubyDiagnosticsVisitor < RBS::AST::Visitor
+  attr_reader :classes #: Hash[String, String]
+  attr_reader :templates #: Hash[Symbol, String]
+
+  def initialize #: void
+    @classes = {}
+    @templates = {}
+  end
+
+  # @rbs ...
+  def visit_declaration_class(node)
+    unless node.annotations.find { _1.string == "diagnostics--skip" }
+      if node.comment
+        name = node.name.to_s
+        classes[name] = node.comment.string
+      end
+    end
+
+    super
+  end
+
+  # @rbs ...
+  def visit_member_method_definition(node)
+    if node.annotations.find { _1.string == "diagnostics--template" }
+      if node.comment
+        templates[node.name] = node.comment.string
+      end
+    end
+  end
+
+  # @rbs (IO) -> void
+  def format_templates(io)
+    io.puts "## Configuration Templates"
+
+    io.puts <<~MD
+      Steep provides several templates to configure diagnostics for Ruby code.
+      You can use these templates or customize them to suit your needs via `#configure_code_diagnostics` method in `Steepfile`.
+
+      The following templates are available:
+
+    MD
+
+    io.puts "<dl>"
+    templates.keys.sort.each do |key|
+      body = templates.fetch(key)
+
+      io.puts "<dt><code>Ruby.#{key}</code></dt>"
+      io.puts "<dd>#{body}</dd>"
+    end
+    io.puts "</dl>"
+    io.puts
+  end
+
+  # @rbs (IO) -> void
+  def format_class(io)
+    classes.keys.sort.each do |key|
+      content = classes[key]
+
+      # io.puts "<h2 id='Ruby::#{key}'>Ruby::#{key}</h2>"
+      io.puts "<a name='Ruby::#{key}'></a>"
+      io.puts "## Ruby::#{key}"
+      io.puts
+      io.puts content
+      io.puts
+
+      configs = templates.keys
+
+      io.puts "### Severity"
+      io.puts
+      io.puts "| #{configs.map { "#{_1}" }.join(" | ")} |"
+      io.puts "| #{configs.map{"-"}.join(" | ")} |"
+
+      line = configs.map {|config|
+        hash = Steep::Diagnostic::Ruby.__send__(config) #: Hash[Class, untyped]
+        const =Steep::Diagnostic::Ruby.const_get(key.to_sym)
+        "#{hash[const] || "-"}"
+      }
+      io.puts "| #{line.join(" | ")} |"
+      io.puts
+    end
+  end
+
+  # @rbs (Pathname) { (instance) -> void } -> void
+  def self.visit_file(path, &block)
+    STDERR.puts "Reading #{path}..."
+    buffer = RBS::Buffer.new(name: path, content: path.read)
+    _, _dirs, decls = RBS::Parser.parse_signature(buffer)
+
+    visitor = new()
+    visitor.visit_all(decls)
+
+    yield visitor
+  end
+end
+
+diagnostic_dir = Pathname(__dir__ || raise) + "../sig/steep/diagnostic"
+output_dir = Pathname(__dir__ || raise) + "../manual"
+
+RubyDiagnosticsVisitor.visit_file(diagnostic_dir + "ruby.rbs") do |visitor|
+  STDERR.puts ">> Writing #{output_dir + "ruby-diagnostics.md"}..."
+  (output_dir + "ruby-diagnostics.md").open("w") do |io|
+    io.puts "# Ruby Code Diagnostics"
+    io.puts
+    visitor.format_templates(io)
+    visitor.format_class(io)
+  end
+end

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 $@