typeprof 0.15.2 → 0.20.2

data/lib/typeprof/builtin.rb

@@ -624,7 +624,7 @@ module TypeProf
     end
 
     def self.file_load(path, ep, env, scratch, &ctn)
-      iseq = ISeq.compile(path)
+      iseq, = ISeq.compile(path)
       callee_ep, callee_env = TypeProf.starting_state(iseq)
       scratch.merge_env(callee_ep, callee_env)
 
@@ -793,27 +793,27 @@ module TypeProf
 
       Import.import_builtin(scratch)
 
-      Type::Builtin[:vmcore]     = scratch.new_class(klass_obj, :VMCore, [], klass_obj, nil)
-      Type::Builtin[:int]        = scratch.get_constant(klass_obj, :Integer)
-      Type::Builtin[:float]      = scratch.get_constant(klass_obj, :Float)
-      Type::Builtin[:rational]   = scratch.get_constant(klass_obj, :Rational)
-      Type::Builtin[:complex]    = scratch.get_constant(klass_obj, :Complex)
-      Type::Builtin[:sym]        = scratch.get_constant(klass_obj, :Symbol)
-      Type::Builtin[:str]        = scratch.get_constant(klass_obj, :String)
-      Type::Builtin[:struct]     = scratch.get_constant(klass_obj, :Struct)
-      Type::Builtin[:ary]        = scratch.get_constant(klass_obj, :Array)
-      Type::Builtin[:hash]       = scratch.get_constant(klass_obj, :Hash)
-      Type::Builtin[:io]         = scratch.get_constant(klass_obj, :IO)
-      Type::Builtin[:proc]       = scratch.get_constant(klass_obj, :Proc)
-      Type::Builtin[:range]      = scratch.get_constant(klass_obj, :Range)
-      Type::Builtin[:regexp]     = scratch.get_constant(klass_obj, :Regexp)
-      Type::Builtin[:matchdata]  = scratch.get_constant(klass_obj, :MatchData)
-      Type::Builtin[:class]      = scratch.get_constant(klass_obj, :Class)
-      Type::Builtin[:module]     = scratch.get_constant(klass_obj, :Module)
-      Type::Builtin[:exc]        = scratch.get_constant(klass_obj, :Exception)
-      Type::Builtin[:encoding]   = scratch.get_constant(klass_obj, :Encoding)
-      Type::Builtin[:enumerator] = scratch.get_constant(klass_obj, :Enumerator)
-      Type::Builtin[:kernel]     = scratch.get_constant(klass_obj, :Kernel)
+      Type::Builtin[:vmcore]     , = scratch.new_class(klass_obj, :VMCore, [], klass_obj, nil)
+      Type::Builtin[:int]        , = scratch.get_constant(klass_obj, :Integer)
+      Type::Builtin[:float]      , = scratch.get_constant(klass_obj, :Float)
+      Type::Builtin[:rational]   , = scratch.get_constant(klass_obj, :Rational)
+      Type::Builtin[:complex]    , = scratch.get_constant(klass_obj, :Complex)
+      Type::Builtin[:sym]        , = scratch.get_constant(klass_obj, :Symbol)
+      Type::Builtin[:str]        , = scratch.get_constant(klass_obj, :String)
+      Type::Builtin[:struct]     , = scratch.get_constant(klass_obj, :Struct)
+      Type::Builtin[:ary]        , = scratch.get_constant(klass_obj, :Array)
+      Type::Builtin[:hash]       , = scratch.get_constant(klass_obj, :Hash)
+      Type::Builtin[:io]         , = scratch.get_constant(klass_obj, :IO)
+      Type::Builtin[:proc]       , = scratch.get_constant(klass_obj, :Proc)
+      Type::Builtin[:range]      , = scratch.get_constant(klass_obj, :Range)
+      Type::Builtin[:regexp]     , = scratch.get_constant(klass_obj, :Regexp)
+      Type::Builtin[:matchdata]  , = scratch.get_constant(klass_obj, :MatchData)
+      Type::Builtin[:class]      , = scratch.get_constant(klass_obj, :Class)
+      Type::Builtin[:module]     , = scratch.get_constant(klass_obj, :Module)
+      Type::Builtin[:exc]        , = scratch.get_constant(klass_obj, :Exception)
+      Type::Builtin[:encoding]   , = scratch.get_constant(klass_obj, :Encoding)
+      Type::Builtin[:enumerator] , = scratch.get_constant(klass_obj, :Enumerator)
+      Type::Builtin[:kernel]     , = scratch.get_constant(klass_obj, :Kernel)
 
       klass_vmcore = Type::Builtin[:vmcore]
       klass_ary    = Type::Builtin[:ary]
@@ -881,7 +881,7 @@ module TypeProf
       # ENV: Hash[String, String]
       str_ty = Type::Instance.new(Type::Builtin[:str])
       env_ty = Type.gen_hash {|h| h[str_ty] = Type.optional(str_ty) }
-      scratch.add_constant(klass_obj, :ENV, env_ty, false)
+      scratch.add_constant(klass_obj, :ENV, env_ty, nil)
 
       scratch.search_method(Type::Builtin[:kernel], false, :sprintf) do |mdefs,|
         mdefs.each do |mdef|

data/lib/typeprof/cli.rb

@@ -18,11 +18,14 @@ module TypeProf
       verbose = 1
 
       options = {}
+      lsp_options = {}
       dir_filter = nil
       gem_rbs_features = []
-      gem_repo_dirs = []
       show_version = false
       max_sec = max_iter = nil
+      collection_path = RBS::Collection::Config::PATH
+
+      load_path_ext = []
 
       opt.separator ""
       opt.separator "Options:"
@@ -30,9 +33,11 @@ module TypeProf
       opt.on("-q", "--quiet", "Do not display progress indicator") { options[:show_indicator] = false }
       opt.on("-v", "--verbose", "Alias to --show-errors") { options[:show_errors] = true }
       opt.on("--version", "Display typeprof version") { show_version = true }
-      opt.on("-I DIR", "Add DIR to the load/require path") {|v| $LOAD_PATH << v }
+      opt.on("-I DIR", "Add DIR to the load/require path") {|v| load_path_ext << v }
       opt.on("-r FEATURE", "Require RBS of the FEATURE gem") {|v| gem_rbs_features << v }
-      opt.on("--repo DIR", "Add DIR to the RBS repository") {|v| gem_repo_dirs << v }
+      opt.on("--collection PATH", "File path of collection configuration") { |v| collection_path = v }
+      opt.on("--no-collection", "Ignore collection configuration") { collection_path = nil }
+      opt.on("--lsp", "LSP mode") {|v| options[:lsp] = true }
 
       opt.separator ""
       opt.separator "Analysis output options:"
@@ -68,8 +73,15 @@ module TypeProf
       opt.on("--debug", "Display analysis log (for debugging purpose)") { verbose = 2 }
       opt.on("--[no-]stackprof MODE", /\Acpu|wall|object\z/, "Enable stackprof (for debugging purpose)") {|v| options[:stackprof] = v.to_sym }
 
+      opt.separator ""
+      opt.separator "LSP options:"
+      opt.on("--port PORT", Integer, "Specify a port number to listen for requests on") {|v| lsp_options[:port] = v }
+      opt.on("--stdio", "Use stdio for LSP transport") {|v| lsp_options[:stdio] = v }
+
       opt.parse!(argv)
 
+      $LOAD_PATH.unshift(*load_path_ext)
+
       dir_filter ||= ConfigData::DEFAULT_DIR_FILTER
       rb_files = []
       rbs_files = []
@@ -82,22 +94,28 @@ module TypeProf
       end
 
       puts "typeprof #{ VERSION }" if show_version
-      if rb_files.empty?
+      if rb_files.empty? && !options[:lsp]
         exit if show_version
         raise OptionParser::InvalidOption.new("no input files")
       end
 
+      if !options[:lsp] && !lsp_options.empty?
+        exit if show_version
+        raise OptionParser::InvalidOption.new("lsp options with non-lsp mode")
+      end
+
       ConfigData.new(
         rb_files: rb_files,
         rbs_files: rbs_files,
         output: output,
         gem_rbs_features: gem_rbs_features,
-        gem_repo_dirs: gem_repo_dirs,
+        collection_path: collection_path,
         verbose: verbose,
         dir_filter: dir_filter,
         max_sec: max_sec,
         max_iter: max_iter,
         options: options,
+        lsp_options: lsp_options,
       )
 
     rescue OptionParser::InvalidOption

data/lib/typeprof/code-range.rb

@@ -0,0 +1,177 @@
+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

@@ -6,12 +6,14 @@ module TypeProf
     :rbs_files,
     :output,
     :gem_rbs_features,
-    :gem_repo_dirs,
+    :collection_path,
     :verbose,
     :dir_filter,
     :max_iter,
     :max_sec,
     :options,
+    :lsp_options,
+    :lsp,
     keyword_init: true
   )
 
@@ -26,7 +28,6 @@ module TypeProf
     def initialize(**opt)
       opt[:output] ||= $stdout
       opt[:gem_rbs_features] ||= []
-      opt[:gem_repo_dirs] ||= []
       opt[:dir_filter] ||= DEFAULT_DIR_FILTER
       opt[:verbose] ||= 0
       opt[:options] ||= {}
@@ -43,6 +44,10 @@ module TypeProf
         union_width_limit: 10,
         stackprof: nil,
       }.merge(opt[:options])
+      opt[:lsp_options] = {
+        port: 0,
+        stdio: false,
+      }.merge(opt[:lsp_options] || {})
       super(**opt)
     end
 
@@ -61,29 +66,36 @@ module TypeProf
     ]
   end
 
-  def self.analyze(config)
-    # Deploy the config to the TypeProf::Config (Note: This is thread unsafe)
-    if TypeProf.const_defined?(:Config)
-      TypeProf.send(:remove_const, :Config)
+  module Config
+    def self.current
+      Thread.current[:typeprof_config]
     end
-    TypeProf.const_set(:Config, config)
 
-    if Config.options[:stackprof]
+    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.options[:stackprof] }.dump"
-      StackProf.start(mode: Config.options[:stackprof], out: out, raw: true)
+      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.gem_rbs_features.each do |feature|
+    Config.current.gem_rbs_features.each do |feature|
       Import.import_library(scratch, feature)
     end
 
     rbs_files = []
     rbs_codes = []
-    Config.rbs_files.each do |rbs|
+    Config.current.rbs_files.each do |rbs|
       if rbs.is_a?(Array) # [String name, String content]
         rbs_codes << rbs
       else
@@ -95,30 +107,39 @@ module TypeProf
       Import.import_rbs_code(scratch, name, content)
     end
 
-    Config.rb_files.each do |rb|
+    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 = ISeq.compile_str(*rb.reverse)
+        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
+    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.output.respond_to?(:write)
-      scratch.report(result, Config.output)
+    if Config.current.output.respond_to?(:write)
+      scratch.report(result, Config.current.output)
     else
-      open(Config.output, "w") do |output|
+      open(Config.current.output, "w") do |output|
         scratch.report(result, output)
       end
     end
 
   rescue TypeProfError => exc
-    exc.report(Config.output)
+    exc.report(Config.current.output)
 
+    return nil
   ensure
-    if Config.options[:stackprof] && defined?(StackProf)
+    if Config.current.options[:stackprof] && defined?(StackProf)
       StackProf.stop
       StackProf.results
     end

data/lib/typeprof/container-type.rb

@@ -307,7 +307,11 @@ module TypeProf
         def screen_name(scratch)
           if @rest_ty == Type.bot
             if @lead_tys.empty?
-              return "Array[bot]" # RBS does not allow an empty tuple "[]"
+              # This is heuristic: in general, an empty array is a wrong guess.
+              # Note that an empty array is representable as "[ ]" in RBS, but
+              # users often have to modify it to "Array[something]".
+              # In this term, "Array[untyped]" is considered more useful than "[ ]".
+              return "Array[untyped]"
             end
             s = @lead_tys.map do |ty|
               ty.screen_name(scratch)
@@ -317,6 +321,9 @@ module TypeProf
           end
 
           "*[#{ squash.screen_name(scratch) }]"
+        rescue SystemStackError
+          p squash
+          exit!
         end
 
         def pretty_print(q)
@@ -673,6 +680,8 @@ module TypeProf
               k_ty = k_ty.union(k)
               v_ty = v_ty.union(v)
             end
+            k_ty = Type.any if k_ty == Type.bot
+            v_ty = Type.any if v_ty == Type.bot
             k_ty = k_ty.screen_name(scratch)
             v_ty = v_ty.screen_name(scratch)
             "Hash[#{ k_ty }, #{ v_ty }]"