typeprof 0.21.11 → 0.30.1

data/lib/typeprof/code-range.rb

@@ -1,177 +0,0 @@
-module TypeProf
-  class CodeLocation
-    # In Ruby, lineno is 1-origin, and column is 0-origin
-    def initialize(lineno, column)
-      @lineno = lineno
-      @column = column
-    end
-
-    def inspect
-      "(%d,%d)" % [@lineno, @column]
-    end
-
-    attr_reader :lineno, :column
-
-    def self.from_lsp(lsp_loc)
-      # In the Language Server Protocol, lineno and column are both 0-origin
-      CodeLocation.new(lsp_loc[:line] + 1, lsp_loc[:character])
-    end
-
-    def to_lsp
-      { line: @lineno - 1, character: @column }
-    end
-
-    def advance_cursor(offset, source_text)
-      new_lineno = @lineno
-      new_column = @column
-      while offset > 0
-        line_text = source_text.lines[new_lineno - 1]
-        if new_column + offset >= line_text.length
-          advanced = line_text.length - new_column
-          offset -= advanced
-          new_lineno += 1
-          new_column = 0
-        else
-          new_column += offset
-          break
-        end
-      end
-      CodeLocation.new(new_lineno, new_column)
-    end
-
-    def <=>(other)
-      ret = @lineno <=> other.lineno
-      return ret if ret != 0
-      @column <=> other.column
-    end
-
-    include Comparable
-  end
-
-  class CodeRange
-    def initialize(first, last)
-      @first, @last = first, last
-    end
-
-    def inspect
-      "%p-%p" % [@first, @last]
-    end
-
-    attr_reader :first
-    attr_reader :last
-
-    def self.from_lsp(lsp_range)
-      CodeRange.new(CodeLocation.from_lsp(lsp[:start]), CodeLocation.from_lsp(lsp[:end]))
-    end
-
-    def self.from_rbs(rbs_loc)
-      CodeRange.new(
-        CodeLocation.new(rbs_loc.start_line, rbs_loc.start_column),
-        CodeLocation.new(rbs_loc.end_line, rbs_loc.end_column),
-      )
-    end
-
-    def to_lsp
-      { start: @first.to_lsp, end: @last.to_lsp }
-    end
-
-    def contain_loc?(loc)
-      @first <= loc && loc < @last
-    end
-
-    def contain?(other)
-      @first <= other.first && other.last <= @last
-    end
-
-    def overlap?(other)
-      if @first <= other.first
-        return @last > other.first
-      else
-        return @first < other.last
-      end
-    end
-  end
-
-  class CodeRangeTable
-    Entry = Struct.new(:range, :value, :children)
-
-    class Entry
-      def inspect
-        "[%p, %p, %p]" % [range, value, children]
-      end
-    end
-
-    def initialize(list = [])
-      @list = list # Array[Entry]
-    end
-
-    def []=(range, value)
-      i_b = @list.bsearch_index {|e| e.range.last > range.first } || @list.size
-      i_e = @list.bsearch_index {|e| e.range.first >= range.last } || @list.size
-      if i_b < i_e
-        # for all i in i_b...i_e, @list[i] overlaps with the range
-        if i_e - i_b == 1
-          if range.contain?(@list[i_b].range)
-            @list[i_b] = Entry[range, value, CodeRangeTable.new(@list[i_b, 1])]
-          elsif @list[i_b].range.contain?(range)
-            @list[i_b].children[range] = value
-          else
-            raise
-          end
-        else
-          if range.contain?(@list[i_b].range) && range.contain?(@list[i_e - 1].range)
-            @list[i_b...i_e] = [Entry[range, value, CodeRangeTable.new(@list[i_b...i_e])]]
-          else
-            raise
-          end
-        end
-      else
-        @list[i_b, 0] = [Entry[range, value, CodeRangeTable.new]]
-      end
-    end
-
-    def [](loc)
-      e = @list.bsearch {|e| e.range.last > loc }
-      if e && e.range.contain_loc?(loc)
-        return e.children[loc] || e.value
-      end
-      return nil
-    end
-  end
-end
-
-if $0 == __FILE__
-  include TypeProf
-  cr1 = CodeRange.new(CodeLocation.new(1, 0), CodeLocation.new(1, 2))
-  cr2 = CodeRange.new(CodeLocation.new(1, 2), CodeLocation.new(1, 4))
-  cr3 = CodeRange.new(CodeLocation.new(2, 0), CodeLocation.new(2, 2))
-  cr4 = CodeRange.new(CodeLocation.new(2, 3), CodeLocation.new(2, 5))
-  cr1and2 = CodeRange.new(CodeLocation.new(1, 0), CodeLocation.new(1, 5))
-  cr3and4 = CodeRange.new(CodeLocation.new(2, 0), CodeLocation.new(2, 5))
-  [[cr1, "A"], [cr2, "B"], [cr3, "C"], [cr4, "D"], [cr1and2, "AB"], [cr3and4, "CD"]].permutation do |ary|
-    tbl = CodeRangeTable.new
-    ary.each do |cr, v|
-      tbl[cr] = v
-    end
-    values = []
-    [1, 2].each do |lineno|
-      (0..5).each do |column|
-        values << tbl[CodeLocation.new(lineno, column)]
-      end
-    end
-    raise if values != ["A", "A", "B", "B", "AB", nil, "C", "C", "CD", "D", "D", nil]
-  end
-
-  source = <<~EOS
-  AB
-  CDE
-  F
-  EOS
-  a_loc = CodeLocation.new(1, 0)
-  b_loc = a_loc.advance_cursor(1, source)
-  raise unless b_loc.inspect == "(1,1)"
-  c_loc = a_loc.advance_cursor(3, source)
-  raise unless c_loc.inspect == "(2,0)"
-  f_loc = c_loc.advance_cursor(4, source)
-  raise unless f_loc.inspect == "(3,0)"
-end

data/lib/typeprof/config.rb

@@ -1,158 +0,0 @@
-require "rbconfig"
-
-module TypeProf
-  ConfigData = Struct.new(
-    :rb_files,
-    :rbs_files,
-    :output,
-    :gem_rbs_features,
-    :collection_path,
-    :verbose,
-    :dir_filter,
-    :max_iter,
-    :max_sec,
-    :options,
-    :lsp_options,
-    :lsp,
-    keyword_init: true
-  )
-
-  class TypeProfError < StandardError
-    def report(output)
-      output.puts "# Analysis Error"
-      output.puts message
-    end
-  end
-
-  class ConfigData
-    def initialize(**opt)
-      opt[:output] ||= $stdout
-      opt[:gem_rbs_features] ||= []
-      opt[:dir_filter] ||= DEFAULT_DIR_FILTER
-      opt[:verbose] ||= 0
-      opt[:options] ||= {}
-      opt[:options] = {
-        exclude_untyped: false,
-        show_typeprof_version: true,
-        show_indicator: true,
-        show_untyped: false,
-        show_errors: false,
-        show_parameter_names: true,
-        show_source_locations: false,
-        stub_execution: true,
-        type_depth_limit: 5,
-        union_width_limit: 10,
-        stackprof: nil,
-      }.merge(opt[:options])
-      opt[:lsp_options] = {
-        port: 0,
-        stdio: false,
-      }.merge(opt[:lsp_options] || {})
-      super(**opt)
-    end
-
-    def check_dir_filter(path)
-      dir_filter.reverse_each do |cond, dir|
-        return cond unless dir
-        return cond if path.start_with?(dir)
-      end
-    end
-
-    DEFAULT_DIR_FILTER = [
-      [:include],
-      [:exclude, RbConfig::CONFIG["prefix"]],
-      [:exclude, Gem.dir],
-      [:exclude, Gem.user_dir],
-    ]
-  end
-
-  module Config
-    def self.current
-      Thread.current[:typeprof_config]
-    end
-
-    def self.set_current(config)
-      Thread.current[:typeprof_config] = config
-    end
-  end
-
-  def self.analyze(config, cancel_token = nil)
-    # Deploy the config to the TypeProf::Config (Note: This is thread local)
-    Config.set_current(config)
-
-    if Config.current.options[:stackprof]
-      require "stackprof"
-      out = "typeprof-stackprof-#{ Config.current.options[:stackprof] }.dump"
-      StackProf.start(mode: Config.current.options[:stackprof], out: out, raw: true)
-    end
-
-    scratch = Scratch.new
-    Builtin.setup_initial_global_env(scratch)
-
-    Config.current.gem_rbs_features.each do |feature|
-      Import.import_library(scratch, feature)
-    end
-
-    rbs_files = []
-    rbs_codes = []
-    Config.current.rbs_files.each do |rbs|
-      if rbs.is_a?(Array) # [String name, String content]
-        rbs_codes << rbs
-      else
-        rbs_files << rbs
-      end
-    end
-    Import.import_rbs_files(scratch, rbs_files)
-    rbs_codes.each do |name, content|
-      Import.import_rbs_code(scratch, name, content)
-    end
-
-    def_code_range_table = nil
-    caller_code_range_table = nil
-    Config.current.rb_files.each do |rb|
-      if rb.is_a?(Array) # [String name, String content]
-        iseq, def_tbl, caller_tbl = ISeq.compile_str(*rb.reverse)
-        def_code_range_table ||= def_tbl
-        caller_code_range_table ||= caller_tbl
-      else
-        iseq = rb
-      end
-      scratch.add_entrypoint(iseq)
-    end
-
-    result = scratch.type_profile(cancel_token)
-
-    if Config.current.options[:lsp]
-      return scratch.report_lsp, def_code_range_table, caller_code_range_table
-    end
-
-    if Config.current.output.respond_to?(:write)
-      scratch.report(result, Config.current.output)
-    else
-      open(Config.current.output, "w") do |output|
-        scratch.report(result, output)
-      end
-    end
-
-  rescue TypeProfError => exc
-    exc.report(Config.current.output)
-
-    return nil
-  ensure
-    if Config.current.options[:stackprof] && defined?(StackProf)
-      StackProf.stop
-      StackProf.results
-    end
-  end
-
-  def self.starting_state(iseq)
-    cref = CRef.new(:bottom, Type::Builtin[:obj], false) # object
-    recv = Type::Instance.new(Type::Builtin[:obj])
-    ctx = Context.new(iseq, cref, nil)
-    ep = ExecutionPoint.new(ctx, 0, nil)
-    locals = [Type.nil] * iseq.locals.size
-    env = Env.new(StaticEnv.new(recv, Type.nil, false, false), locals, [], Utils::HashWrapper.new({}))
-
-    return ep, env
-  end
-end