typeprof 0.15.2 → 0.20.2

data/lib/typeprof/export.rb

@@ -26,7 +26,7 @@ module TypeProf
     end
 
     def show_message(terminated, output)
-      if Config.options[:show_typeprof_version]
+      if Config.current.options[:show_typeprof_version]
         output.puts "# TypeProf #{ VERSION }"
         output.puts
       end
@@ -38,7 +38,7 @@ module TypeProf
 
     def show_error(errors, backward_edge, output)
       return if errors.empty?
-      return unless Config.options[:show_errors]
+      return unless Config.current.options[:show_errors]
 
       output.puts "# Errors"
       errors.each do |ep, msg|
@@ -110,16 +110,17 @@ module TypeProf
       @scratch.namespace = class_def.name
 
       consts = {}
-      class_def.consts.each do |name, (ty, absolute_path)|
+      class_def.consts.each do |name, (ty, loc)|
+        next unless loc
         next if ty.is_a?(Type::Class)
-        next if !absolute_path || Config.check_dir_filter(absolute_path) == :exclude
+        next if Config.current.check_dir_filter(loc[0]) == :exclude
         consts[name] = ty.screen_name(@scratch)
       end
 
       modules = class_def.modules.to_h do |kind, mods|
         mods = mods.to_h do |singleton, mods|
           mods = mods.filter_map do |mod_def, _type_args, absolute_paths|
-            next if absolute_paths.all? {|path| !path || Config.check_dir_filter(path) == :exclude }
+            next if absolute_paths.all? {|path| !path || Config.current.check_dir_filter(path) == :exclude }
             Type::Instance.new(mod_def.klass_obj).screen_name(@scratch)
           end
           [singleton, mods]
@@ -142,7 +143,7 @@ module TypeProf
 
             ctx = ctxs.find {|ctx| ctx.mid == mid } || ctxs.first
 
-            next if Config.check_dir_filter(ctx.iseq.absolute_path) == :exclude
+            next if Config.current.check_dir_filter(ctx.iseq.absolute_path) == :exclude
 
             method_name = mid
             method_name = "self.#{ method_name }" if singleton
@@ -152,7 +153,7 @@ module TypeProf
             source_locations[key] ||= ctx.iseq.source_location(0)
             (methods[key] ||= []) << @scratch.show_method_signature(ctx)
           when AliasMethodDef
-            next if mdef.def_ep && Config.check_dir_filter(mdef.def_ep.source_location) == :exclude
+            next if mdef.def_ep && Config.current.check_dir_filter(mdef.def_ep.source_location) == :exclude
             alias_name, orig_name = mid, mdef.orig_mid
             if singleton
               alias_name = "self.#{ alias_name }"
@@ -165,7 +166,7 @@ module TypeProf
           when AttrMethodDef
             next if !mdef.def_ep
             absolute_path = mdef.def_ep.ctx.iseq.absolute_path
-            next if !absolute_path || Config.check_dir_filter(absolute_path) == :exclude
+            next if !absolute_path || Config.current.check_dir_filter(absolute_path) == :exclude
             mid = mid.to_s[0..-2].to_sym if mid.to_s.end_with?("=")
             method_name = mid
             method_name = "self.#{ mid }" if singleton
@@ -188,13 +189,14 @@ module TypeProf
               key = [:rbs, method_name]
               methods[key] = sigs
               visibilities[key] ||= mdef.pub_meth
+              source_locations[key] ||= mdef.iseq&.source_location(0)
             end
           end
         end
       end
 
       ivars = ivars.map do |(singleton, var), entry|
-        next if entry.absolute_paths.all? {|path| Config.check_dir_filter(path) == :exclude }
+        next if entry.absolute_paths.all? {|path| Config.current.check_dir_filter(path) == :exclude }
         ty = entry.type
         next unless var.to_s.start_with?("@")
         var = "self.#{ var }" if singleton
@@ -204,12 +206,12 @@ module TypeProf
       end.compact
 
       cvars = cvars.map do |var, entry|
-        next if entry.absolute_paths.all? {|path| Config.check_dir_filter(path) == :exclude }
+        next if entry.absolute_paths.all? {|path| Config.current.check_dir_filter(path) == :exclude }
         next if entry.rbs_declared
         [var, entry.type.screen_name(@scratch)]
       end.compact
 
-      if !class_def.absolute_path || Config.check_dir_filter(class_def.absolute_path) == :exclude
+      if !class_def.absolute_path || Config.current.check_dir_filter(class_def.absolute_path) == :exclude
         if methods.keys.all? {|type,| type == :rbs }
           return nil if consts.empty? && modules[:before][true].empty? && modules[:before][false].empty? && modules[:after][true].empty? && modules[:after][false].empty? && ivars.empty? && cvars.empty? && inner_classes.empty?
         end
@@ -232,8 +234,182 @@ module TypeProf
       )
     end
 
+    def conv_class_lsp(namespace, class_def)
+      @scratch.namespace = namespace
+
+      if class_def.klass_obj.superclass != :__root__ && class_def.klass_obj.superclass
+        omit = class_def.klass_obj.superclass == Type::Builtin[:obj] || class_def.klass_obj == Type::Builtin[:obj]
+        superclass = omit ? nil : @scratch.get_class_name(class_def.klass_obj.superclass)
+        type_args = class_def.klass_obj.superclass_type_args
+        if type_args && !type_args.empty?
+          superclass += "[#{ type_args.map {|ty| ty.screen_name(@scratch) }.join(", ") }]"
+        end
+      end
+
+      @scratch.namespace = class_def.name
+
+      consts = {}
+      class_def.consts.each do |name, (ty, loc)|
+        next unless loc
+        next if ty.is_a?(Type::Class)
+        next if Config.current.check_dir_filter(loc[0]) == :exclude
+        consts[name] = ty.screen_name(@scratch)
+      end
+
+      modules = class_def.modules.to_h do |kind, mods|
+        mods = mods.to_h do |singleton, mods|
+          mods = mods.filter_map do |mod_def, _type_args, absolute_paths|
+            next if absolute_paths.all? {|path| !path || Config.current.check_dir_filter(path) == :exclude }
+            Type::Instance.new(mod_def.klass_obj).screen_name(@scratch)
+          end
+          [singleton, mods]
+        end
+        [kind, mods]
+      end
+
+      visibilities = {}
+      source_locations = {}
+      methods = {}
+      ivars = class_def.ivars.dump
+      cvars = class_def.cvars.dump
+
+      class_def.methods.each do |(singleton, mid), mdefs|
+        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
+
+            next if Config.current.check_dir_filter(ctx.iseq.absolute_path) == :exclude
+
+            method_name = mid
+            method_name = "self.#{ method_name }" if singleton
+
+            key = [:iseq, method_name]
+            visibilities[key] ||= mdef.pub_meth
+            source_locations[key] ||= [ctx.iseq.source_location(0)]
+            sig = @scratch.show_method_signature(ctx)
+            (methods[key] ||= []) << sig if sig
+          when AliasMethodDef
+            alias_name, orig_name = mid, mdef.orig_mid
+            if singleton
+              alias_name = "self.#{ alias_name }"
+              orig_name = "self.#{ orig_name }"
+            end
+            key = [:alias, alias_name]
+            visibilities[key] ||= mdef.pub_meth
+            source_locations[key] ||= [mdef.def_ep&.source_location]
+            methods[key] = orig_name
+          when AttrMethodDef
+            next if !mdef.def_ep
+            absolute_path = mdef.def_ep.ctx.iseq.absolute_path
+            next if !absolute_path || Config.current.check_dir_filter(absolute_path) == :exclude
+            mid = mid.to_s[0..-2].to_sym if mid.to_s.end_with?("=")
+            method_name = mid
+            method_name = "self.#{ mid }" if singleton
+            method_name = [method_name, :"@#{ mid }" != mdef.ivar]
+            key = [:attr, method_name]
+            visibilities[key] ||= mdef.pub_meth
+            source_locations[key] ||= [mdef.def_ep.source_location]
+            if methods[key]
+              if methods[key][0] != mdef.kind
+                methods[key][0] = :accessor
+              end
+            else
+              entry = ivars[[singleton, mdef.ivar]]
+              ty = entry ? entry.type : Type.any
+              methods[key] = [mdef.kind, ty.screen_name(@scratch), ty.include_untyped?(@scratch)]
+            end
+          when TypedMethodDef
+            if mdef.rbs_source
+              method_name, sigs, rbs_code_range = mdef.rbs_source
+              key = [:rbs, method_name]
+              methods[key] = sigs
+              visibilities[key] ||= mdef.pub_meth
+              source_locations[key] ||= [mdef.iseq&.source_location(0), rbs_code_range]
+            end
+          end
+        end
+      end
+
+      ivars = ivars.map do |(singleton, var), entry|
+        next if entry.absolute_paths.all? {|path| Config.current.check_dir_filter(path) == :exclude }
+        ty = entry.type
+        next unless var.to_s.start_with?("@")
+        var = "self.#{ var }" if singleton
+        next if methods[[:attr, [singleton ? "self.#{ var.to_s[1..] }" : var.to_s[1..].to_sym, false]]]
+        next if entry.rbs_declared
+        [var, ty.screen_name(@scratch)]
+      end.compact
+
+      cvars = cvars.map do |var, entry|
+        next if entry.absolute_paths.all? {|path| Config.current.check_dir_filter(path) == :exclude }
+        next if entry.rbs_declared
+        [var, entry.type.screen_name(@scratch)]
+      end.compact
+
+      if !class_def.absolute_path || Config.current.check_dir_filter(class_def.absolute_path) == :exclude
+        if methods.keys.all? {|type,| type == :rbs }
+          return nil if consts.empty? && modules[:before][true].empty? && modules[:before][false].empty? && modules[:after][true].empty? && modules[:after][false].empty? && ivars.empty? && cvars.empty?
+        end
+      end
+
+      @scratch.namespace = nil
+
+      ClassData.new(
+        kind: class_def.kind,
+        name: class_def.name,
+        superclass: superclass,
+        consts: consts,
+        modules: modules,
+        ivars: ivars,
+        cvars: cvars,
+        methods: methods,
+        visibilities: visibilities,
+        source_locations: source_locations,
+      )
+    end
+
     ClassData = Struct.new(:kind, :name, :superclass, :consts, :modules, :ivars, :cvars, :methods, :visibilities, :source_locations, :inner_classes, keyword_init: true)
 
+    def show_lsp
+      res = []
+      @class_defs.each_value do |class_def|
+        class_data = conv_class_lsp([], class_def)
+        next unless class_data
+        class_data.methods.each do |key, arg|
+          source_location, rbs_code_range = class_data.source_locations[key]
+          type, (method_name, hidden) = key
+          case type
+          when :attr
+            kind, ty, untyped = *arg
+            line = "attr_#{ kind } #{ method_name }#{ hidden ? "()" : "" }: #{ ty }"
+          when :rbs
+            sigs = arg.sort.join(" | ")
+            line = "# def #{ method_name }: #{ sigs }"
+          when :iseq
+            sigs = []
+            untyped = false
+            arg.each do |sig, untyped0|
+              sigs << sig
+              untyped ||= untyped0
+            end
+            sigs = sigs.sort.join(" | ")
+            line = "def #{ method_name }: #{ sigs }"
+          when :alias
+            orig_name = arg
+            line = "alias #{ method_name } #{ orig_name }"
+          end
+          if source_location =~ /:(\d+)$/
+            res << [$`, $1.to_i, line, rbs_code_range, class_data.kind, class_data.name]
+          end
+        end
+      end
+      res
+    end
+
     def show(stat_eps, output)
       # make the class hierarchy
       root = {}
@@ -270,7 +446,7 @@ module TypeProf
         coverage = {}
         stat_eps.each do |ep|
           path = ep.ctx.iseq.path
-          lineno = ep.ctx.iseq.linenos[ep.pc] - 1
+          lineno = ep.ctx.iseq.insns[ep.pc].lineno - 1
           (coverage[path] ||= [])[lineno] ||= 0
           (coverage[path] ||= [])[lineno] += 1
         end
@@ -340,7 +516,7 @@ module TypeProf
           prev_vis = vis
         end
         source_location = class_data.source_locations[key]
-        if Config.options[:show_source_locations] && source_location
+        if Config.current.options[:show_source_locations] && source_location
           lines << nil
           lines << (indent + "  # #{ source_location }")
         end
@@ -348,7 +524,7 @@ module TypeProf
         case type
         when :attr
           kind, ty, untyped = *arg
-          exclude = Config.options[:exclude_untyped] && untyped ? "#" : " " # XXX
+          exclude = Config.current.options[:exclude_untyped] && untyped ? "#" : " " # XXX
           lines << (indent + "#{ exclude } attr_#{ kind } #{ method_name }#{ hidden ? "()" : "" }: #{ ty }")
         when :rbs
           sigs = arg.sort.join("\n" + indent + "#" + " " * (method_name.size + 5) + "| ")
@@ -361,7 +537,7 @@ module TypeProf
             untyped ||= untyped0
           end
           sigs = sigs.sort.join("\n" + indent + " " * (method_name.size + 6) + "| ")
-          exclude = Config.options[:exclude_untyped] && untyped ? "#" : " " # XXX
+          exclude = Config.current.options[:exclude_untyped] && untyped ? "#" : " " # XXX
           lines << (indent + "#{ exclude } def #{ method_name }: #{ sigs }")
         when :alias
           orig_name = arg

data/lib/typeprof/import.rb

@@ -4,31 +4,49 @@ module TypeProf
   class RBSReader
     def initialize
       @repo = RBS::Repository.new
-      Config.gem_repo_dirs.each do |dir|
-        @repo.add(Pathname(dir))
+      collection_path = Config.current.collection_path
+      if collection_path&.exist?
+        collection_lock = RBS::Collection::Config.lockfile_of(collection_path)
+        @repo.add(collection_lock.repo_path)
       end
-      @env, @builtin_env_json = RBSReader.get_builtin_env
+      @env, @loaded_gems, @builtin_env_json = RBSReader.get_builtin_env
     end
 
     @builtin_env = @builtin_env_json = nil
     def self.get_builtin_env
+      @loaded_gems = []
       unless @builtin_env
         @builtin_env = RBS::Environment.new
 
-        loader = RBS::EnvironmentLoader.new(repository: @repo)
+        loader = RBS::EnvironmentLoader.new
+
+        # TODO: invalidate this cache when rbs_collection.yml was changed
+        collection_path = Config.current.collection_path
+        if collection_path&.exist?
+          collection_lock = RBS::Collection::Config.lockfile_of(collection_path)
+          collection_lock.gems.each {|gem| @loaded_gems << gem["name"] }
+          loader.add_collection(collection_lock)
+        end
+
         new_decls = loader.load(env: @builtin_env).map {|decl,| decl }
         @builtin_env_json = load_rbs(@builtin_env, new_decls)
       end
 
-      return @builtin_env.dup, @builtin_env_json
+      return @builtin_env.dup, @loaded_gems.dup, @builtin_env_json
     end
 
     def load_builtin
       @builtin_env_json
     end
 
+    class RBSCollectionDefined < StandardError; end
+
     def load_library(lib)
       loader = RBS::EnvironmentLoader.new(core_root: nil, repository: @repo)
+      if @loaded_gems.include?(lib)
+        raise RBSCollectionDefined
+      end
+      @loaded_gems << lib
       loader.add(library: lib)
 
       case lib
@@ -157,7 +175,11 @@ module TypeProf
               end
 
               method_def = conv_method_def(method_types, visibility)
-              rbs_source = [(member.kind == :singleton ? "self." : "") + member.name.to_s, member.types.map {|type| type.location.source }]
+              rbs_source = [
+                (member.kind == :singleton ? "self." : "") + member.name.to_s,
+                member.types.map {|type| type.location.source },
+                [member.location.name, CodeRange.from_rbs(member.location)],
+              ]
               if member.instance?
                 methods[[false, name]] = method_def
                 rbs_sources[[false, name]] = rbs_source
@@ -459,11 +481,14 @@ module TypeProf
         end
       when RBS::Types::Union
         [:union, ty.types.map {|ty2| conv_type(ty2) }.compact]
+      when RBS::Types::Intersection
+        [:intersection, ty.types.map {|ty2| conv_type(ty2) }.compact]
       when RBS::Types::Optional
         [:optional, conv_type(ty.type)]
       when RBS::Types::Interface
         # XXX: Currently, only a few builtin interfaces are supported
         case ty.to_s
+        when "::_ToS" then [:str]
         when "::_ToStr" then [:str]
         when "::_ToInt" then [:int]
         when "::_ToAry[U]" then [:array, [:Array], [], [:var, :U]]
@@ -471,6 +496,7 @@ module TypeProf
           [:instance, conv_type_name(ty.name)]
         end
       when RBS::Types::Bases::Instance then [:any] # XXX: not implemented yet
+      when RBS::Types::Bases::Class then [:any] # XXX: not implemented yet
       when RBS::Types::Record
         [:hash_record, [:Hash], ty.fields.map {|key, ty| [key, conv_type(ty)] }]
       when RBS::Types::Proc
@@ -496,7 +522,7 @@ module TypeProf
         json = scratch.rbs_reader.load_library(feature)
       rescue RBS::EnvironmentLoader::UnknownLibraryError
         return nil
-      rescue RBS::DuplicatedDeclarationError
+      rescue RBS::DuplicatedDeclarationError, RBSReader::RBSCollectionDefined
         return true
       end
       # need cache?
@@ -527,7 +553,7 @@ module TypeProf
         superclass = path_to_klass(superclass) if superclass
         base_klass = path_to_klass(classpath[0..-2])
 
-        klass = @scratch.get_constant(base_klass, name)
+        klass, = @scratch.get_constant(base_klass, name)
         if klass.is_a?(Type::Any)
           klass = @scratch.new_class(base_klass, name, type_params, superclass, nil)
 
@@ -729,6 +755,9 @@ module TypeProf
       when :union
         tys = ty[1]
         Type::Union.create(Utils::Set[*tys.map {|ty2| conv_type(ty2) }], nil) # XXX: Array and Hash support
+      when :intersection
+        tys = ty[1]
+        conv_type(tys.first) # XXX: This is wrong! We need to support intersection type
       when :var
         Type::Var.new(ty[1])
       when :proc
@@ -743,7 +772,7 @@ module TypeProf
     def path_to_klass(path)
       klass = Type::Builtin[:obj]
       path.each do |name|
-        klass = @scratch.get_constant(klass, name)
+        klass, = @scratch.get_constant(klass, name)
         if klass == Type.any
           raise TypeProfError.new("A constant `#{ path.join("::") }' is used but not defined in RBS")
         end

data/lib/typeprof/insns-def.rb

@@ -21,6 +21,7 @@ TypeProf::INSN_TABLE = {:nop=>[],
  :putstring=>["VALUE"],
  :concatstrings=>["rb_num_t"],
  :tostring=>[],
+ :anytostring=>[],
  :freezestring=>["VALUE"],
  :toregexp=>["rb_num_t", "rb_num_t"],
  :intern=>[],