typeprof 0.9.0 → 0.12.0

data/lib/typeprof/container-type.rb

@@ -45,6 +45,12 @@ module TypeProf
           Type::Cell.new(Type::Cell::Elements.new([Type.bot] * klass.type_params.size), base_type)
         end
       end
+
+      def include_untyped?(scratch)
+        return true if @base_type.include_untyped?(scratch)
+        return true if @elems.include_untyped?(scratch)
+        false
+      end
     end
 
     # The most basic container type for default type parameter class
@@ -196,6 +202,10 @@ module TypeProf
           end
           Elements.new(elems)
         end
+
+        def include_untyped?(scratch)
+          return @elems.any? {|ty| ty.include_untyped?(scratch) }
+        end
       end
     end
 
@@ -531,6 +541,12 @@ module TypeProf
             return rest_ary_ty, following_tys
           end
         end
+
+        def include_untyped?(scratch)
+          return true if @lead_tys.any? {|ty| ty.include_untyped?(scratch) }
+          return true if @rest_ty.include_untyped?(scratch)
+          false
+        end
       end
     end
 
@@ -790,6 +806,14 @@ module TypeProf
           end
           kw_tys
         end
+
+        def include_untyped?(scratch)
+          @map_tys.each do |key, val|
+            return true if key.include_untyped?(scratch)
+            return true if val.include_untyped?(scratch)
+          end
+          false
+        end
       end
     end
 

data/lib/typeprof/export.rb

@@ -26,6 +26,10 @@ module TypeProf
     end
 
     def show_message(terminated, output)
+      if Config.options[:show_typeprof_version]
+        output.puts "# TypeProf #{ VERSION }"
+        output.puts
+      end
       if terminated
         output.puts "# CAUTION: Type profiling was terminated prematurely because of the limitation"
         output.puts
@@ -94,6 +98,10 @@ module TypeProf
       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
@@ -105,19 +113,20 @@ module TypeProf
         consts[name] = ty.screen_name(@scratch)
       end
 
-      included_mods = class_def.modules[false].filter_map do |mod_def, _type_args, absolute_paths|
-        next if absolute_paths.all? {|path| !path || Config.check_dir_filter(path) == :exclude }
-        Type::Instance.new(mod_def.klass_obj).screen_name(@scratch)
-      end
-
-      extended_mods = class_def.modules[true].filter_map do |mod_def, _type_args, absolute_paths|
-        next if absolute_paths.all? {|path| !path || Config.check_dir_filter(path) == :exclude }
-        Type::Instance.new(mod_def.klass_obj).screen_name(@scratch)
+      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 }
+            Type::Instance.new(mod_def.klass_obj).screen_name(@scratch)
+          end
+          [singleton, mods]
+        end
+        [kind, mods]
       end
 
-      explicit_methods = {}
-      iseq_methods = {}
-      attr_methods = {}
+      visibilities = {}
+      source_locations = {}
+      methods = {}
       ivars = class_def.ivars.dump
       cvars = class_def.cvars.dump
 
@@ -135,29 +144,47 @@ module TypeProf
               method_name = ctx.mid
               method_name = "self.#{ method_name }" if singleton
 
-              iseq_methods[method_name] ||= [true, []]
-              iseq_methods[method_name][0] &&= mdef.pub_meth
-              iseq_methods[method_name][1] << @scratch.show_method_signature(ctx)
+              key = [:iseq, method_name]
+              visibilities[key] ||= mdef.pub_meth
+              source_locations[key] ||= ctx.iseq.source_location(0)
+              (methods[key] ||= []) << @scratch.show_method_signature(ctx)
+            end
+          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.absolute_path || Config.check_dir_filter(mdef.absolute_path) == :exclude
+            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
             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]
-            if attr_methods[method_name]
-              if attr_methods[method_name][0] != mdef.kind
-                attr_methods[method_name][0] = :accessor
+            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
-              attr_methods[method_name] = [mdef.kind, ty.screen_name(@scratch)]
+              methods[key] = [mdef.kind, ty.screen_name(@scratch), ty.include_untyped?(@scratch)]
             end
           when TypedMethodDef
             if mdef.rbs_source
               method_name, sigs = mdef.rbs_source
-              explicit_methods[method_name] = sigs
+              key = [:rbs, method_name]
+              methods[key] = sigs
+              visibilities[key] ||= mdef.pub_meth
             end
           end
         end
@@ -168,7 +195,7 @@ module TypeProf
         ty = entry.type
         next unless var.to_s.start_with?("@")
         var = "self.#{ var }" if singleton
-        next if attr_methods[[singleton ? "self.#{ var.to_s[1..] }" : var.to_s[1..].to_sym, false]]
+        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
@@ -180,7 +207,9 @@ module TypeProf
       end.compact
 
       if !class_def.absolute_path || Config.check_dir_filter(class_def.absolute_path) == :exclude
-        return nil if consts.empty? && included_mods.empty? && extended_mods.empty? && ivars.empty? && cvars.empty? && iseq_methods.empty? && attr_methods.empty? && inner_classes.empty?
+        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
       end
 
       @scratch.namespace = nil
@@ -190,18 +219,17 @@ module TypeProf
         name: class_def.name,
         superclass: superclass,
         consts: consts,
-        included_mods: included_mods,
-        extended_mods: extended_mods,
+        modules: modules,
         ivars: ivars,
         cvars: cvars,
-        attr_methods: attr_methods,
-        explicit_methods: explicit_methods,
-        iseq_methods: iseq_methods,
+        methods: methods,
+        visibilities: visibilities,
+        source_locations: source_locations,
         inner_classes: inner_classes,
       )
     end
 
-    ClassData = Struct.new(:kind, :name, :superclass, :consts, :included_mods, :extended_mods, :ivars, :cvars, :attr_methods, :explicit_methods, :iseq_methods, :inner_classes, keyword_init: true)
+    ClassData = Struct.new(:kind, :name, :superclass, :consts, :modules, :ivars, :cvars, :methods, :visibilities, :source_locations, :inner_classes, keyword_init: true)
 
     def show(stat_eps, output)
       # make the class hierarchy
@@ -218,7 +246,16 @@ module TypeProf
 
       output.puts "# Classes" # and Modules
 
-      show_class_hierarchy(0, hierarchy, output, true)
+      prev_nil = true
+      show_class_hierarchy(0, hierarchy).each do |line|
+        if line == nil
+          output.puts line unless prev_nil
+          prev_nil = true
+        else
+          output.puts line
+          prev_nil = false
+        end
+      end
 
       if ENV["TP_STAT"]
         output.puts ""
@@ -246,13 +283,13 @@ module TypeProf
       end.compact
     end
 
-    def show_class_hierarchy(depth, hierarchy, output, first)
+    def show_class_hierarchy(depth, hierarchy)
+      lines = []
       hierarchy.each do |class_data|
-        output.puts unless first
-        first = false
-
-        show_class_data(depth, class_data, output)
+        lines << nil
+        lines.concat show_class_data(depth, class_data)
       end
+      lines
     end
 
     def show_const(namespace, path)
@@ -262,53 +299,77 @@ module TypeProf
       path[i..].join("::")
     end
 
-    def show_class_data(depth, class_data, output)
+    def show_class_data(depth, class_data)
       indent = "  " * depth
       name = class_data.name.last
       superclass = " < " + class_data.superclass if class_data.superclass
-      output.puts indent + "#{ class_data.kind } #{ name }#{ superclass }"
-      first = true
+      first_line = indent + "#{ class_data.kind } #{ name }#{ superclass }"
+      lines = []
       class_data.consts.each do |name, ty|
-        output.puts indent + "  #{ name }: #{ ty }"
-        first = false
-      end
-      class_data.included_mods.sort.each do |mod|
-        output.puts indent + "  include #{ mod }"
-        first = false
+        lines << (indent + "  #{ name }: #{ ty }")
       end
-      class_data.extended_mods.sort.each do |mod|
-        output.puts indent + "  extend #{ mod }"
-        first = false
+      class_data.modules.each do |kind, mods|
+        mods.each do |singleton, mods|
+          case
+          when kind == :before &&  singleton then directive = nil
+          when kind == :before && !singleton then directive = "prepend"
+          when kind == :after  &&  singleton then directive = "extend"
+          when kind == :after  && !singleton then directive = "include"
+          end
+          mods.each do |mod|
+            lines << (indent + "  #{ directive } #{ mod }") if directive
+          end
+        end
       end
       class_data.ivars.each do |var, ty|
-        output.puts indent + "  #{ var }: #{ ty }" unless var.start_with?("_")
-        first = false
+        lines << (indent + "  #{ var }: #{ ty }") unless var.start_with?("_")
       end
       class_data.cvars.each do |var, ty|
-        output.puts indent + "  #{ var }: #{ ty }"
-        first = false
+        lines << (indent + "  #{ var }: #{ ty }")
       end
-      class_data.attr_methods.each do |(method_name, hidden), (kind, ty)|
-        output.puts indent + "  attr_#{ kind } #{ method_name }#{ hidden ? "()" : "" }: #{ ty }"
-        first = false
-      end
-      class_data.explicit_methods.each do |method_name, sigs|
-        sigs = sigs.sort.join("\n" + indent + "#" + " " * (method_name.size + 6) + "| ")
-        output.puts indent + "# def #{ method_name }: #{ sigs }"
-        first = false
-      end
-      prev_pub_meth = true
-      class_data.iseq_methods.each do |method_name, (pub_meth, sigs)|
-        sigs = sigs.sort.join("\n" + indent + " " * (method_name.size + 7) + "| ")
-        if prev_pub_meth != pub_meth
-          output.puts indent + "  #{ pub_meth ? "public" : "private" }"
-          prev_pub_meth = pub_meth
+      lines << nil
+      prev_vis = true
+      class_data.methods.each do |key, arg|
+        vis = class_data.visibilities[key]
+        if prev_vis != vis
+          lines << nil
+          lines << (indent + "  #{ vis ? "public" : "private" }")
+          prev_vis = vis
+        end
+        source_location = class_data.source_locations[key]
+        if Config.options[:show_source_locations] && source_location
+          lines << nil
+          lines << (indent + "  # #{ source_location }")
+        end
+        type, (method_name, hidden) = key
+        case type
+        when :attr
+          kind, ty, untyped = *arg
+          exclude = Config.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) + "| ")
+          lines << (indent + "# def #{ method_name }: #{ sigs }")
+        when :iseq
+          sigs = []
+          untyped = false
+          arg.each do |sig, untyped0|
+            sigs << sig
+            untyped ||= untyped0
+          end
+          sigs = sigs.sort.join("\n" + indent + " " * (method_name.size + 6) + "| ")
+          exclude = Config.options[:exclude_untyped] && untyped ? "#" : " " # XXX
+          lines << (indent + "#{ exclude } def #{ method_name }: #{ sigs }")
+        when :alias
+          orig_name = arg
+          lines << (indent + "  alias #{ method_name } #{ orig_name }")
         end
-        output.puts indent + "  def #{ method_name }: #{ sigs }"
-        first = false
       end
-      show_class_hierarchy(depth + 1, class_data.inner_classes, output, first)
-      output.puts indent + "end"
+      lines.concat show_class_hierarchy(depth + 1, class_data.inner_classes)
+      lines.shift until lines.empty? || lines.first
+      lines.pop until lines.empty? || lines.last
+      lines.unshift first_line
+      lines << (indent + "end")
     end
   end
 end

data/lib/typeprof/import.rb

@@ -3,6 +3,10 @@ require "rbs"
 module TypeProf
   class RBSReader
     def initialize
+      @repo = RBS::Repository.new
+      Config.gem_repo_dirs.each do |dir|
+        @repo.add(Pathname(dir))
+      end
       @env, @builtin_env_json = RBSReader.get_builtin_env
     end
 
@@ -11,7 +15,7 @@ module TypeProf
       unless @builtin_env
         @builtin_env = RBS::Environment.new
 
-        loader = RBS::EnvironmentLoader.new
+        loader = RBS::EnvironmentLoader.new(repository: @repo)
         new_decls = loader.load(env: @builtin_env).map {|decl,| decl }
         @builtin_env_json = load_rbs(@builtin_env, new_decls)
       end
@@ -24,22 +28,30 @@ module TypeProf
     end
 
     def load_library(lib)
-      loader = RBS::EnvironmentLoader.new(core_root: nil)
+      loader = RBS::EnvironmentLoader.new(core_root: nil, repository: @repo)
       loader.add(library: lib)
 
       case lib
+      when 'bigdecimal-math'
+        loader.add(library: 'bigdecimal')
       when "yaml"
         loader.add(library: "pstore")
         loader.add(library: "dbm")
+      when "logger"
+        loader.add(library: "monitor")
+      when "csv"
+        loader.add(library: "forwardable")
+      when "prime"
+        loader.add(library: "singleton")
       end
 
       new_decls = loader.load(env: @env).map {|decl,| decl }
       RBSReader.load_rbs(@env, new_decls)
     end
 
-    def load_path(path)
-      loader = RBS::EnvironmentLoader.new(core_root: nil)
-      loader.add(path: path)
+    def load_paths(paths)
+      loader = RBS::EnvironmentLoader.new(core_root: nil, repository: @repo)
+      paths.each {|path| loader.add(path: path) }
       new_decls = loader.load(env: @env).map {|decl,| decl }
       RBSReader.load_rbs(@env, new_decls)
     end
@@ -69,6 +81,7 @@ module TypeProf
   class RBS2JSON
     def initialize(all_env, cur_env)
       @all_env, @cur_env = all_env, cur_env
+      @alias_resolution_stack = {}
     end
 
     def dump_json
@@ -116,13 +129,13 @@ module TypeProf
         end
 
         type_params = nil
-        included_modules = []
-        extended_modules = []
+        modules = { include: [], extend: [], prepend: [] }
         methods = {}
         attr_methods = {}
         ivars = {}
         cvars = {}
         rbs_sources = {}
+        visibility = true
 
         decls.each do |decl|
           decl = decl.decl
@@ -143,7 +156,7 @@ module TypeProf
                 end
               end
 
-              method_def = conv_method_def(method_types)
+              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 }]
               if member.instance?
                 methods[[false, name]] = method_def
@@ -155,13 +168,13 @@ module TypeProf
               end
             when RBS::AST::Members::AttrReader
               ty = conv_type(member.type)
-              attr_methods[[false, member.name]] = attr_method_def(:reader, member.name, ty)
+              attr_methods[[false, member.name]] = attr_method_def(:reader, member.name, ty, visibility)
             when RBS::AST::Members::AttrWriter
               ty = conv_type(member.type)
-              attr_methods[[false, member.name]] = attr_method_def(:writer, member.name, ty)
+              attr_methods[[false, member.name]] = attr_method_def(:writer, member.name, ty, visibility)
             when RBS::AST::Members::AttrAccessor
               ty = conv_type(member.type)
-              attr_methods[[false, member.name]] = attr_method_def(:accessor, member.name, ty)
+              attr_methods[[false, member.name]] = attr_method_def(:accessor, member.name, ty, visibility)
             when RBS::AST::Members::Alias
               # XXX: an alias to attr methods?
               if member.instance?
@@ -178,7 +191,7 @@ module TypeProf
               if name.kind == :class
                 mod = conv_type_name(name)
                 type_args = member.args.map {|type| conv_type(type) }
-                included_modules << [mod, type_args]
+                modules[:include] << [mod, type_args]
               else
                 # including an interface is not supported yet
               end
@@ -188,7 +201,17 @@ module TypeProf
               if name.kind == :class
                 mod = conv_type_name(name)
                 type_args = member.args.map {|type| conv_type(type) }
-                extended_modules << [mod, type_args]
+                modules[:extend] << [mod, type_args]
+              else
+                # extending a module with an interface is not supported yet
+              end
+
+            when RBS::AST::Members::Prepend
+              name = member.name
+              if name.kind == :class
+                mod = conv_type_name(name)
+                type_args = member.args.map {|type| conv_type(type) }
+                modules[:prepend] << [mod, type_args]
               else
                 # extending a module with an interface is not supported yet
               end
@@ -198,7 +221,10 @@ module TypeProf
             when RBS::AST::Members::ClassVariable
               cvars[member.name] = conv_type(member.type)
 
-            when RBS::AST::Members::Public, RBS::AST::Members::Private # XXX
+            when RBS::AST::Members::Public
+              visibility = true
+            when RBS::AST::Members::Private
+              visibility = false
 
             # The following declarations are ignoreable because they are handled in other level
             when RBS::AST::Declarations::Constant
@@ -216,8 +242,7 @@ module TypeProf
           type_params: type_params,
           superclass: superclass,
           members: {
-            included_modules: included_modules,
-            extended_modules: extended_modules,
+            modules: modules,
             methods: methods,
             attr_methods: attr_methods,
             ivars: ivars,
@@ -297,10 +322,14 @@ module TypeProf
       return RBS::BuiltinNames::Object.name, []
     end
 
-    def conv_method_def(rbs_method_types)
-      rbs_method_types.map do |method_type|
+    def conv_method_def(rbs_method_types, visibility)
+      sig_rets = rbs_method_types.map do |method_type|
         conv_func(method_type.type_params, method_type.type, method_type.block)
       end
+      {
+        sig_rets: sig_rets,
+        visibility: visibility,
+      }
     end
 
     def conv_func(type_params, func, block)
@@ -330,11 +359,12 @@ module TypeProf
       }
     end
 
-    def attr_method_def(kind, name, ty)
+    def attr_method_def(kind, name, ty, visibility)
       {
         kind: kind,
         ivar: name,
         ty: ty,
+        visibility: visibility,
       }
     end
 
@@ -407,8 +437,17 @@ module TypeProf
           raise NotImplementedError
         end
       when RBS::Types::Alias
-        alias_decl = @all_env.alias_decls[ty.name]
-        alias_decl ? conv_type(alias_decl.decl.type) : [:any]
+        if @alias_resolution_stack[ty.name]
+          [:any]
+        else
+          begin
+            @alias_resolution_stack[ty.name] = true
+            alias_decl = @all_env.alias_decls[ty.name]
+            alias_decl ? conv_type(alias_decl.decl.type) : [:any]
+          ensure
+            @alias_resolution_stack.delete(ty.name)
+          end
+        end
       when RBS::Types::Union
         [:union, ty.types.map {|ty2| conv_type(ty2) }.compact]
       when RBS::Types::Optional
@@ -455,9 +494,9 @@ module TypeProf
       Import.new(scratch, json).import
     end
 
-    def self.import_rbs_file(scratch, rbs_path)
-      rbs_path = Pathname(rbs_path) unless rbs_path.is_a?(Pathname)
-      Import.new(scratch, scratch.rbs_reader.load_path(rbs_path)).import(true)
+    def self.import_rbs_files(scratch, rbs_paths)
+      rbs_paths = rbs_paths.map {|rbs_path| Pathname(rbs_path) }
+      Import.new(scratch, scratch.rbs_reader.load_paths(rbs_paths)).import(true)
     end
 
     def self.import_rbs_code(scratch, rbs_name, rbs_code)
@@ -502,22 +541,25 @@ module TypeProf
 
       classes.each do |klass, superclass_type_args, members|
         @scratch.add_superclass_type_args!(klass, superclass_type_args&.map {|ty| conv_type(ty) })
-        included_modules = members[:included_modules]
-        extended_modules = members[:extended_modules]
+        modules = members[:modules]
         methods = members[:methods]
         attr_methods = members[:attr_methods]
         ivars = members[:ivars]
         cvars = members[:cvars]
         rbs_sources = members[:rbs_sources]
 
-        included_modules.each do |mod, type_args|
-          type_args = type_args&.map {|ty| conv_type(ty) }
-          @scratch.include_module(klass, path_to_klass(mod), type_args, false, nil)
-        end
-
-        extended_modules.each do |mod, type_args|
-          type_args = type_args&.map {|ty| conv_type(ty) }
-          @scratch.include_module(klass, path_to_klass(mod), type_args, true, nil)
+        modules.each do |kind, mods|
+          mods.each do |mod, type_args|
+            type_args = type_args&.map {|ty| conv_type(ty) }
+            case kind
+            when :include
+              @scratch.mix_module(:after, klass, path_to_klass(mod), type_args, false, nil)
+            when :extend
+              @scratch.mix_module(:after, klass, path_to_klass(mod), type_args, true, nil)
+            when :prepend
+              @scratch.mix_module(:before, klass, path_to_klass(mod), type_args, false, nil)
+            end
+          end
         end
 
         methods.each do |(singleton, method_name), mdef|
@@ -530,7 +572,7 @@ module TypeProf
           kind = mdef[:kind]
           ivar = mdef[:ivar]
           ty = conv_type(mdef[:ty]).remove_type_vars
-          @scratch.add_attr_method(klass, nil, ivar, :"@#{ ivar }", kind)
+          @scratch.add_attr_method(klass, ivar, :"@#{ ivar }", kind, mdef[:visibility], nil)
           @scratch.add_ivar_write!(Type::Instance.new(klass), :"@#{ ivar }", ty, nil)
         end
 
@@ -560,11 +602,11 @@ module TypeProf
     end
 
     def conv_method_def(method_name, mdef, rbs_source)
-      sig_rets = mdef.flat_map do |sig_ret|
+      sig_rets = mdef[:sig_rets].flat_map do |sig_ret|
         conv_func(sig_ret)
       end
 
-      TypedMethodDef.new(sig_rets, rbs_source)
+      TypedMethodDef.new(sig_rets, rbs_source, mdef[:visibility])
     end
 
     def conv_func(sig_ret)
@@ -664,7 +706,9 @@ module TypeProf
       klass = Type::Builtin[:obj]
       path.each do |name|
         klass = @scratch.get_constant(klass, name)
-        raise path.inspect if klass == Type.any
+        if klass == Type.any
+          raise TypeProfError.new("A constant `#{ path.join("::") }' is used but not defined in RBS")
+        end
       end
       klass
     end