In Files

  • typeprof-0.21.1/lib/typeprof.rb
  • typeprof-0.21.1/lib/typeprof/analyzer.rb
  • typeprof-0.21.1/lib/typeprof/arguments.rb
  • typeprof-0.21.1/lib/typeprof/block.rb
  • typeprof-0.21.1/lib/typeprof/builtin.rb
  • typeprof-0.21.1/lib/typeprof/cli.rb
  • typeprof-0.21.1/lib/typeprof/code-range.rb
  • typeprof-0.21.1/lib/typeprof/config.rb
  • typeprof-0.21.1/lib/typeprof/container-type.rb
  • typeprof-0.21.1/lib/typeprof/export.rb
  • typeprof-0.21.1/lib/typeprof/import.rb
  • typeprof-0.21.1/lib/typeprof/insns-def.rb
  • typeprof-0.21.1/lib/typeprof/iseq.rb
  • typeprof-0.21.1/lib/typeprof/lsp.rb
  • typeprof-0.21.1/lib/typeprof/method.rb
  • typeprof-0.21.1/lib/typeprof/type.rb
  • typeprof-0.21.1/lib/typeprof/utils.rb
  • typeprof-0.21.1/lib/typeprof/version.rb

Class/Module Index [+]

Quicksearch

TypeProf

Public Class Methods

analyze(config, cancel_token = nil) click to toggle source 
 
               # File typeprof-0.21.1/lib/typeprof/config.rb, line 79
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
start_lsp_server(config) click to toggle source 
 
               # File typeprof-0.21.1/lib/typeprof/lsp.rb, line 6
def self.start_lsp_server(config)
  if config.lsp_options[:stdio]
    reader = LSP::Reader.new($stdin)
    writer = LSP::Writer.new($stdout)
    # pipe all builtin print output to stderr to avoid conflicting with lsp
    $stdout = $stderr
    TypeProf::LSP::Server.new(config, reader, writer).run
  else
    Socket.tcp_server_sockets("localhost", config.lsp_options[:port]) do |servs|
      serv = servs[0].local_address
      $stdout << JSON.generate({
        host: serv.ip_address,
        port: serv.ip_port,
        pid: $$,
      })
      $stdout.flush

      $stdout = $stderr

      Socket.accept_loop(servs) do |sock|
        sock.set_encoding("UTF-8")
        begin
          reader = LSP::Reader.new(sock)
          writer = LSP::Writer.new(sock)
          TypeProf::LSP::Server.new(config, reader, writer).run
        ensure
          sock.close
        end
        exit
      end
    end
  end
end
starting_state(iseq) click to toggle source 
 
               # File typeprof-0.21.1/lib/typeprof/config.rb, line 148
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