typeprof 0.15.1 → 0.20.1

data/lib/typeprof/analyzer.rb

@@ -43,6 +43,14 @@ module TypeProf
       end
     end
 
+    def detailed_source_location(pc)
+      if @iseq
+        @iseq.detailed_source_location(pc)
+      else
+        nil
+      end
+    end
+
     def replace_cref(cref)
       Context.new(@iseq, cref, @mid)
     end
@@ -66,6 +74,14 @@ module TypeProf
       end
     end
 
+    def detailed_source_location(_pc)
+      if @caller_ep
+        @caller_ep.source_location
+      else
+        nil
+      end
+    end
+
     def replace_cref(cref)
       # What to do?
     end
@@ -101,6 +117,14 @@ module TypeProf
     def source_location
       @ctx.source_location(@pc)
     end
+
+    def detailed_source_location
+      @ctx.detailed_source_location(@pc)
+    end
+
+    def absolute_path
+      @ctx.iseq.absolute_path
+    end
   end
 
   class StaticEnv
@@ -287,6 +311,9 @@ module TypeProf
 
       @types_being_shown = []
       @namespace = nil
+
+      @lsp_completion = nil
+      @lsp_signature_help = CodeRangeTable.new
     end
 
     def add_entrypoint(iseq)
@@ -335,7 +362,7 @@ module TypeProf
         @subclasses = []
       end
 
-      attr_reader :kind, :modules, :consts, :methods, :ivars, :cvars, :absolute_path, :subclasses
+      attr_reader :kind, :modules, :methods, :ivars, :cvars, :absolute_path, :subclasses
       attr_accessor :name, :klass_obj
 
       def mix_module(kind, mod, type_args, singleton, absolute_path)
@@ -350,24 +377,43 @@ module TypeProf
       end
 
       def get_constant(name)
-        ty, = @consts[name]
-        ty || Type.any # XXX: warn?
+        ty, locs = @consts[name]
+        ty = ty || Type.any # XXX: warn?
+        return ty, locs
       end
 
-      def add_constant(name, ty, absolute_path)
+      def add_constant(name, ty, def_ep)
         if @consts[name]
           # XXX: warn!
+          _, eps = @consts[name]
+          @consts[name] = [ty, eps + [def_ep&.detailed_source_location]]
+          return
+        end
+        @consts[name] = [ty, [def_ep&.detailed_source_location]]
+      end
+
+      def consts
+        @consts.lazy.flat_map do |name, (ty, eps)|
+          eps.map do |ep|
+            [name, [ty, ep]]
+          end
         end
-        @consts[name] = [ty, absolute_path]
       end
 
+      def add_class_open(name, open_ep)
+        ty, eps = @consts[name]
+        raise "call this only if the class is opened more than once" if ty.nil?
+        @consts[name] = [ty, eps + [open_ep&.detailed_source_location]]
+      end
+
+
       def adjust_substitution_for_module(mods, mid, mthd, subst, &blk)
         mods.each do |mod_def, type_args,|
           if mod_def.klass_obj.type_params && type_args
             subst2 = {}
             mod_def.klass_obj.type_params.zip(type_args) do |(tyvar, *), tyarg|
               tyvar = Type::Var.new(tyvar)
-              subst2[tyvar] = tyarg.substitute(subst, Config.options[:type_depth_limit])
+              subst2[tyvar] = tyarg.substitute(subst, Config.current.options[:type_depth_limit])
             end
             mod_def.adjust_substitution(false, mid, mthd, subst2, false, &blk)
           end
@@ -444,23 +490,23 @@ module TypeProf
       cbase && cbase.idx != 1 ? @class_defs[cbase.idx].name : []
     end
 
-    def new_class(cbase, name, type_params, superclass, absolute_path)
+    def new_class(cbase, name, type_params, superclass, def_ep)
       show_name = cbase_path(cbase) + [name]
       idx = @class_defs.size
       if superclass
-        @class_defs[idx] = ClassDef.new(:class, show_name, absolute_path)
+        @class_defs[idx] = ClassDef.new(:class, show_name, def_ep&.absolute_path)
         @class_defs[superclass.idx].subclasses << idx unless superclass == :__root__
         klass = Type::Class.new(:class, idx, type_params, superclass, show_name)
         @class_defs[idx].klass_obj = klass
         cbase ||= klass # for bootstrap
-        add_constant(cbase, name, klass, absolute_path)
+        add_constant(cbase, name, klass, def_ep)
         return klass
       else
         # module
-        @class_defs[idx] = ClassDef.new(:module, show_name, absolute_path)
+        @class_defs[idx] = ClassDef.new(:module, show_name, def_ep&.absolute_path)
         mod = Type::Class.new(:module, idx, type_params, nil, show_name)
         @class_defs[idx].klass_obj = mod
-        add_constant(cbase, name, mod, absolute_path)
+        add_constant(cbase, name, mod, def_ep)
         return mod
       end
     end
@@ -519,7 +565,7 @@ module TypeProf
             subst2 = {}
             klass.superclass.type_params.zip(klass.superclass_type_args) do |(tyvar, *), tyarg|
               tyvar = Type::Var.new(tyvar)
-              subst2[tyvar] = tyarg.substitute(subst, Config.options[:type_depth_limit])
+              subst2[tyvar] = tyarg.substitute(subst, Config.current.options[:type_depth_limit])
             end
             subst = subst2
           end
@@ -601,29 +647,53 @@ module TypeProf
       nil
     end
 
+    def get_all_methods(klass, singleton, _include_subclasses)
+      names = {}
+
+      if klass.kind == :class
+        while klass != :__root__
+          # TODO: module
+          @class_defs[klass.idx].methods.each_key do |singleton0, name|
+            if singleton == singleton0
+              names[name] = true
+            end
+          end
+          klass = klass.superclass
+        end
+      else
+        @class_defs[klass.idx].methods.each_key do |singleton0, name|
+          if singleton == singleton0
+            names[name] = true
+          end
+        end
+      end
+
+      names
+    end
+
     def get_constant(klass, name)
       if klass == Type.any
-        Type.any
+        [Type.any, nil]
       elsif klass.is_a?(Type::Class)
         @class_defs[klass.idx].get_constant(name)
       else
-        Type.any
+        [Type.any, nil]
       end
     end
 
     def search_constant(cref, name)
       while cref != :bottom
-        val = get_constant(cref.klass, name)
-        return val if val != Type.any
+        ty, locs = get_constant(cref.klass, name)
+        return ty, locs if ty != Type.any
         cref = cref.outer
       end
 
-      Type.any
+      return Type.any, nil
     end
 
-    def add_constant(klass, name, value, user_defined)
+    def add_constant(klass, name, value, def_ep)
       if klass.is_a?(Type::Class)
-        @class_defs[klass.idx].add_constant(name, value, user_defined)
+        @class_defs[klass.idx].add_constant(name, value, def_ep)
       end
     end
 
@@ -694,7 +764,13 @@ module TypeProf
     end
 
     def add_callsite!(callee_ctx, caller_ep, caller_env, &ctn)
-      @executed_iseqs << callee_ctx.iseq if callee_ctx.is_a?(Context)
+      if callee_ctx.is_a?(Context)
+        @executed_iseqs << callee_ctx.iseq
+        callee_type = callee_ctx.iseq.type
+        if caller_ep.ctx.is_a?(Context) && (callee_type == :method || callee_type == :block)
+          caller_ep.ctx.iseq&.add_called_iseq(caller_ep.pc, callee_ctx.iseq)
+        end
+      end
 
       @callsites[callee_ctx] ||= {}
       @callsites[callee_ctx][caller_ep] = ctn
@@ -743,23 +819,23 @@ module TypeProf
     end
 
     class VarTable
-      Entry = Struct.new(:rbs_declared, :read_continuations, :type, :absolute_paths)
+      Entry = Struct.new(:rbs_declared, :read_continuations, :type, :absolute_paths, :write_eps)
 
       def initialize
         @tbl = {}
       end
 
       def add_read!(site, ep, &ctn)
-        entry = @tbl[site] ||= Entry.new(false, {}, Type.bot, Utils::MutableSet.new)
+        entry = @tbl[site] ||= Entry.new(false, {}, Type.bot, Utils::MutableSet.new, Utils::MutableSet.new)
         entry.read_continuations[ep] = ctn
         entry.absolute_paths << ep.ctx.iseq.absolute_path if ep.ctx.is_a?(Context)
         ty = entry.type
         ty = Type.nil if ty == Type.bot
-        ctn[ty, ep]
+        ctn[ty, ep, entry.write_eps]
       end
 
       def add_write!(site, ty, ep, scratch)
-        entry = @tbl[site] ||= Entry.new(!ep, {}, Type.bot, Utils::MutableSet.new)
+        entry = @tbl[site] ||= Entry.new(!ep, {}, Type.bot, Utils::MutableSet.new, Utils::MutableSet.new)
         if ep
           if entry.rbs_declared
             unless Type.match?(ty, entry.type)
@@ -768,10 +844,11 @@ module TypeProf
             end
           end
           entry.absolute_paths << ep.ctx.iseq.absolute_path
+          entry.write_eps << ep
         end
         entry.type = entry.type.union(ty)
-        entry.read_continuations.each do |ep, ctn|
-          ctn[ty, ep]
+        entry.read_continuations.each do |read_ep, ctn|
+          ctn[ty, read_ep, [ep]]
         end
       end
 
@@ -815,7 +892,8 @@ module TypeProf
       recv.each_child do |recv|
         class_def, singleton = get_ivar(recv, var)
         next unless class_def
-        class_def.ivars.add_write!([singleton, var], ty, ep, self)
+        site = [singleton, var]
+        class_def.ivars.add_write!(site, ty, ep, self)
       end
     end
 
@@ -846,18 +924,18 @@ module TypeProf
     end
 
     def error(ep, msg)
-      p [ep.source_location, "[error] " + msg] if Config.verbose >= 2
+      p [ep.source_location, "[error] " + msg] if Config.current.verbose >= 2
       @errors << [ep, "[error] " + msg]
     end
 
     def warn(ep, msg)
-      p [ep.source_location, "[warning] " + msg] if Config.verbose >= 2
+      p [ep.source_location, "[warning] " + msg] if Config.current.verbose >= 2
       @errors << [ep, "[warning] " + msg]
     end
 
     def reveal_type(ep, ty)
       key = ep.source_location
-      puts "reveal:#{ ep.source_location }:#{ ty.screen_name(self) }" if Config.verbose >= 2
+      puts "reveal:#{ ep.source_location }:#{ ty.screen_name(self) }" if Config.current.verbose >= 2
       if @reveal_types[key]
         @reveal_types[key] = @reveal_types[key].union(ty)
       else
@@ -924,8 +1002,9 @@ module TypeProf
       end
     end
 
-    def type_profile
-      start_time = tick = Time.now
+    def type_profile(cancel_token = nil)
+      cancel_token ||= Utils::TimerCancelToken.new(Config.current.max_sec)
+      tick = Time.now
       iter_counter = 0
       stat_eps = Utils::MutableSet.new
 
@@ -938,7 +1017,7 @@ module TypeProf
         if entrypoint.is_a?(String)
           file = entrypoint
           next if @loaded_files[File.expand_path(file)]
-          iseq = ISeq.compile(file)
+          iseq, = ISeq.compile(file)
         else
           iseq = entrypoint
         end
@@ -953,7 +1032,7 @@ module TypeProf
             ep = @worklist.deletemin
 
             iter_counter += 1
-            if Config.options[:show_indicator]
+            if Config.current.options[:show_indicator]
               tick2 = Time.now
               if tick2 - tick >= 1
                 tick = tick2
@@ -962,7 +1041,7 @@ module TypeProf
               end
             end
 
-            if (Config.max_sec && Time.now - start_time >= Config.max_sec) || (Config.max_iter && Config.max_iter <= iter_counter)
+            if (Config.current.max_iter && Config.current.max_iter <= iter_counter) || cancel_token.cancelled?
               @terminated = true
               break
             end
@@ -973,7 +1052,7 @@ module TypeProf
 
           break if @terminated
 
-          break unless Config.options[:stub_execution]
+          break unless Config.current.options[:stub_execution]
 
           begin
             iseq, (kind, dummy_continuation) = @pending_execution.first
@@ -981,7 +1060,7 @@ module TypeProf
             @pending_execution.delete(iseq)
           end while @executed_iseqs.include?(iseq)
 
-          puts "DEBUG: trigger stub execution (#{ iseq&.name || "(nil)" }): rest #{ @pending_execution.size }" if Config.verbose >= 2
+          puts "DEBUG: trigger stub execution (#{ iseq&.name || "(nil)" }): rest #{ @pending_execution.size }" if Config.current.verbose >= 2
 
           break if !iseq
           case kind
@@ -1000,7 +1079,7 @@ module TypeProf
         end
       end
 
-      $stderr.print "\r\e[K" if Config.options[:show_indicator]
+      $stderr.print "\r\e[K" if Config.current.options[:show_indicator]
 
       stat_eps
     end
@@ -1017,13 +1096,70 @@ module TypeProf
       RubySignatureExporter.new(self, @class_defs, @iseq_method_to_ctxs).show(stat_eps, output)
     end
 
+    def report_lsp
+      errs = @errors.map do |ep, msg|
+        [ep&.detailed_source_location, msg]
+      end
+
+      res = RubySignatureExporter.new(self, @class_defs, @iseq_method_to_ctxs).show_lsp
+
+      path, loc = Config.current.options[:signature_help_loc]
+      if path
+        sig_help_res = []
+        sig_help = @lsp_signature_help[loc]
+        if sig_help
+          recv = sig_help[:recv]
+          mid = sig_help[:mid]
+          singleton = sig_help[:singleton]
+          mdefs = sig_help[:mdefs]
+          node_id = sig_help[:node_id]
+          mdefs.each do |mdef|
+            case mdef
+            when ISeqMethodDef
+              ctxs = @iseq_method_to_ctxs[mdef]
+              next unless ctxs
+
+              ctx = ctxs.find {|ctx| ctx.mid == mid } || ctxs.first
+
+              method_name = mid
+              method_name = "self.#{ method_name }" if singleton
+
+              str = recv.screen_name(self)
+              str += singleton ? "." : "#"
+              str += method_name.to_s
+              str += ": "
+              sig, _, sig_help = show_method_signature(ctx)
+              offset = str.size
+              sig_help = sig_help.transform_values {|r| (r.begin + offset ... r.end + offset) }
+              str += sig
+              sig_help_res << [str, sig_help, node_id]
+            when AliasMethodDef
+              # TODO
+            when TypedMethodDef
+              mdef.rbs_source&.[](1)&.each do |rbs|
+                # TODO: sig_help
+                sig_help_res << [rbs, {}, node_id]
+              end
+            end
+          end
+        end
+      end
+
+      {
+        sigs: res,
+        errors: errs,
+        completion: @lsp_completion,
+        signature_help: sig_help_res,
+      }
+    end
+
     def globalize_type(ty, env, ep)
       if ep.outer
         tmp_ep = ep
         tmp_ep = tmp_ep.outer while tmp_ep.outer
         env = @return_envs[tmp_ep]
       end
-      ty.globalize(env, {}, Config.options[:type_depth_limit])
+      ty.globalize(env, {}, Config.current.options[:type_depth_limit])
     end
 
     def localize_type(ty, env, ep, alloc_site = AllocationSite.new(ep))
@@ -1031,13 +1167,13 @@ module TypeProf
         tmp_ep = ep
         tmp_ep = tmp_ep.outer while tmp_ep.outer
         target_env = @return_envs[tmp_ep]
-        target_env, ty = ty.localize(target_env, alloc_site, Config.options[:type_depth_limit])
+        target_env, ty = ty.localize(target_env, alloc_site, Config.current.options[:type_depth_limit])
         merge_return_env(tmp_ep) do |env|
           env ? env.merge(target_env) : target_env
         end
         return env, ty
       else
-        return ty.localize(env, alloc_site, Config.options[:type_depth_limit])
+        return ty.localize(env, alloc_site, Config.current.options[:type_depth_limit])
       end
     end
 
@@ -1099,13 +1235,16 @@ module TypeProf
     end
 
     def get_instance_variable(recv, var, ep, env)
-      add_ivar_read!(recv, var, ep) do |ty, ep|
+      add_ivar_read!(recv, var, ep) do |ty, ep, write_eps|
         alloc_site = AllocationSite.new(ep)
         nenv, ty = localize_type(ty, env, ep, alloc_site)
         case ty
         when Type::Local
           @alloc_site_to_global_id[ty.id] = [recv, var] # need overwrite check??
         end
+        write_eps.each do |write_ep|
+          ep.ctx.iseq.add_def_loc(ep.pc, write_ep.detailed_source_location)
+        end
         yield ty, nenv
       end
     end
@@ -1122,7 +1261,7 @@ module TypeProf
       insn = ep.ctx.iseq.insns[ep.pc]
       operands = insn.operands
 
-      if Config.verbose >= 2
+      if Config.current.verbose >= 2
         # XXX: more dedicated output
         puts "DEBUG: stack=%p" % [env.stack]
         puts "DEBUG: %s (%s) PC=%d insn=%s sp=%d" % [ep.source_location, ep.ctx.iseq.name, ep.pc, insn.insn, env.stack.size]
@@ -1291,8 +1430,10 @@ module TypeProf
         case flags & 7
         when 0, 2 # CLASS / MODULE
           type = (flags & 7) == 2 ? :module : :class
-          existing_klass = get_constant(cbase, id) # TODO: multiple return values
+          existing_klass, = get_constant(cbase, id) # TODO: multiple return values
           if existing_klass.is_a?(Type::Class)
+            # record re-opening location
+            @class_defs[cbase.idx].add_class_open(id, ep)
             klass = existing_klass
           else
             if existing_klass != Type.any
@@ -1317,7 +1458,7 @@ module TypeProf
               superclass = nil
             end
             if cbase.is_a?(Type::Class)
-              klass = new_class(cbase, id, [], superclass, ep.ctx.iseq.absolute_path)
+              klass = new_class(cbase, id, [], superclass, ep)
               if superclass
                 add_superclass_type_args!(klass, superclass.type_params.map { Type.any })
 
@@ -1631,7 +1772,7 @@ module TypeProf
         var, = operands
         ty = Type.builtin_global_variable_type(var)
         if ty
-          ty = get_constant(Type::Builtin[:obj], ty) if ty.is_a?(Symbol)
+          ty, locs = get_constant(Type::Builtin[:obj], ty) if ty.is_a?(Symbol)
           env, ty = localize_type(ty, env, ep)
           env = env.push(ty)
         else
@@ -1776,21 +1917,29 @@ module TypeProf
         name, = operands
         env, (cbase, _allow_nil,) = env.pop(2)
         if cbase == Type.nil
-          ty = search_constant(ep.ctx.cref, name)
+          ty, locs = search_constant(ep.ctx.cref, name)
           env, ty = localize_type(ty, env, ep)
           env = env.push(ty)
         elsif cbase == Type.any
           env = env.push(Type.any) # XXX: warning needed?
         else
-          ty = get_constant(cbase, name)
+          ty, locs = get_constant(cbase, name)
           env, ty = localize_type(ty, env, ep)
           env = env.push(ty)
         end
+        locs&.each do |loc|
+          ep.ctx.iseq.add_def_loc(ep.pc, loc)
+        end
       when :setconstant
         name, = operands
         env, (ty, cbase) = env.pop(2)
-        old_ty = get_constant(cbase, name)
-        if old_ty != Type.any # XXX???
+        old_ty, old_locs = get_constant(cbase, name)
+        if old_locs == [nil] # RBS defined
+          # TODO: it would be better to check if ty is consistent with old_ty (defined in RBS)
+          # instead of extending the type
+          env, old_ty = localize_type(globalize_type(old_ty, env, ep), env, ep)
+          ty = ty.union(old_ty)
+        elsif old_ty != Type.any # XXX???
           warn(ep, "already initialized constant #{ Type::Instance.new(cbase).screen_name(self) }::#{ name }")
         end
         ty.each_child do |ty|
@@ -1798,7 +1947,7 @@ module TypeProf
             @class_defs[ty.idx].name = cbase_path(cbase) + [name]
           end
         end
-        add_constant(cbase, name, globalize_type(ty, env, ep), ep.ctx.iseq.absolute_path)
+        add_constant(cbase, name, globalize_type(ty, env, ep), ep)
 
       when :getspecial
         key, type = operands
@@ -2186,10 +2335,26 @@ module TypeProf
         merge_return_env(ep) {|tenv| tenv ? tenv.merge(env) : env }
       end
 
+      aargs.node_id = opt[:node_id]
+
       return env, recv, mid, aargs
     end
 
     def do_send(recvs, mid, aargs, ep, env, &ctn)
+      if mid == :__typeprof_lsp_completion
+        names = {}
+        recvs.each_child do |recv|
+          case recv
+          when Type::Void, Type::Any
+          else
+            klass, singleton, include_subclasses = recv.method_dispatch_info
+            names.merge!(get_all_methods(klass, singleton, include_subclasses)) if klass
+          end
+        end
+        @lsp_completion = names
+        return ctn[Type.any, ep, env]
+      end
+
       recvs.each_child do |recv|
         case recv
         when Type::Void
@@ -2201,6 +2366,19 @@ module TypeProf
           klass, singleton, include_subclasses = recv.method_dispatch_info
           meths = get_method(klass, singleton, include_subclasses, mid) if klass
           if meths
+            path, loc = Config.current.options[:signature_help_loc]
+            if path && path == ep.ctx.iseq.path && mid != :inherited # XXX: too ad-hoc!!!
+              path, code_range = ep&.detailed_source_location
+              if path && code_range&.contain_loc?(loc)
+                @lsp_signature_help[code_range] = {
+                  recv: recv,
+                  mid: mid,
+                  singleton: singleton,
+                  mdefs: meths,
+                  node_id: aargs.node_id,
+                }
+              end
+            end
             meths.each do |meth|
               meth.do_send(recv, mid, aargs, ep, env, self, &ctn)
             end
@@ -2282,7 +2460,7 @@ module TypeProf
 
       bsig ||= BlockSignature.new([], [], nil, Type.nil)
 
-      bsig = bsig.screen_name(nil, self)
+      bsig, = bsig.screen_name(nil, self)
       ret_ty = ret_ty.screen_name(self)
       ret_ty = (ret_ty.include?("|") ? "(#{ ret_ty })" : ret_ty) # XXX?
 
@@ -2317,7 +2495,7 @@ module TypeProf
 
       begin
         @types_being_shown << farg_tys << ret_ty
-        farg_tys = farg_tys ? farg_tys.screen_name(nil, self) : "(unknown)"
+        farg_tys, = farg_tys ? farg_tys.screen_name(nil, self) : ["(unknown)"]
         ret_ty = ret_ty.screen_name(self)
         ret_ty = (ret_ty.include?("|") ? "(#{ ret_ty })" : ret_ty) # XXX?
 
@@ -2330,15 +2508,16 @@ module TypeProf
 
     def show_method_signature(ctx)
       farg_tys = @method_signatures[ctx]
+      return nil unless farg_tys
       ret_ty = ctx.mid == :initialize ? Type::Void.new : @return_values[ctx] || Type.bot
 
       untyped = farg_tys.include_untyped?(self) || ret_ty.include_untyped?(self)
 
-      farg_tys = farg_tys.screen_name(ctx.iseq, self)
+      farg_tys, ranges = farg_tys.screen_name(ctx.iseq, self)
       ret_ty = ret_ty.screen_name(self)
       ret_ty = (ret_ty.include?("|") ? "(#{ ret_ty })" : ret_ty) # XXX?
 
-      ["#{ (farg_tys.empty? ? "" : "#{ farg_tys } ") }-> #{ ret_ty }", untyped]
+      return "#{ (farg_tys.empty? ? "" : "#{ farg_tys } ") }-> #{ ret_ty }", untyped, ranges
     end
   end
 end

data/lib/typeprof/arguments.rb

@@ -16,6 +16,7 @@ module TypeProf
     end
 
     attr_reader :lead_tys, :rest_ty, :kw_tys, :blk_ty
+    attr_accessor :node_id
 
     def globalize(caller_env, visited, depth)
       lead_tys = @lead_tys.map {|ty| ty.globalize(caller_env, visited, depth) }