typeprof 0.9.2 → 0.14.0

data/lib/typeprof/cli.rb

@@ -20,6 +20,7 @@ module TypeProf
       options = {}
       dir_filter = nil
       gem_rbs_features = []
+      gem_repo_dirs = []
       show_version = false
       max_sec = max_iter = nil
 
@@ -31,6 +32,7 @@ module TypeProf
       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("-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.separator ""
       opt.separator "Analysis output options:"
@@ -46,8 +48,12 @@ module TypeProf
         dir_filter ||= ConfigData::DEFAULT_DIR_FILTER
         dir_filter << [:exclude, File.expand_path(dir)]
       end
+      opt.on("--exclude-untyped", "Exclude (comment out) all entries including untyped") {|v| options[:exclude_untyped] = v }
+      opt.on("--[no-]show-typeprof-version", "Display TypeProf version in a header") {|v| options[:show_typeprof_version] = v }
       opt.on("--[no-]show-errors", "Display possible errors found during the analysis") {|v| options[:show_errors] = v }
       opt.on("--[no-]show-untyped", "Display \"Foo | untyped\" instead of \"Foo\"") {|v| options[:show_untyped] = v }
+      opt.on("--[no-]show-parameter-names", "Display parameter names for methods") {|v| options[:show_parameter_names] = v }
+      opt.on("--[no-]show-source-locations", "Display definition source locations for methods") {|v| options[:show_source_locations] = v }
 
       opt.separator ""
       opt.separator "Analysis limit options:"
@@ -85,6 +91,7 @@ module TypeProf
         rbs_files: rbs_files,
         output: output,
         gem_rbs_features: gem_rbs_features,
+        gem_repo_dirs: gem_repo_dirs,
         verbose: verbose,
         dir_filter: dir_filter,
         max_sec: max_sec,

data/lib/typeprof/config.rb

@@ -6,6 +6,7 @@ module TypeProf
     :rbs_files,
     :output,
     :gem_rbs_features,
+    :gem_repo_dirs,
     :verbose,
     :dir_filter,
     :max_iter,
@@ -14,17 +15,29 @@ module TypeProf
     keyword_init: true
   )
 
+  class TypeProfError < StandardError
+    def report(output)
+      output.puts "# Analysis Error"
+      output.puts message
+    end
+  end
+
   class ConfigData
     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] ||= {}
       opt[:options] = {
+        exclude_untyped: false,
+        show_typeprof_version: true,
         show_indicator: true,
         show_untyped: false,
         show_errors: false,
+        show_parameter_names: true,
+        show_source_locations: false,
         stub_execution: true,
         type_depth_limit: 5,
         stackprof: nil,
@@ -67,9 +80,19 @@ module TypeProf
       Import.import_library(scratch, feature)
     end
 
-    prologue_ctx = Context.new(nil, nil, nil)
-    prologue_ep = ExecutionPoint.new(prologue_ctx, -1, nil)
-    prologue_env = Env.new(TopStaticEnv.new, [], [], Utils::HashWrapper.new({}))
+    rbs_files = []
+    rbs_codes = []
+    Config.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
 
     Config.rb_files.each do |rb|
       if rb.is_a?(Array) # [String name, String content]
@@ -77,17 +100,7 @@ module TypeProf
       else
         iseq = ISeq.compile(rb)
       end
-      ep, env = TypeProf.starting_state(iseq)
-      scratch.merge_env(ep, env)
-      scratch.add_callsite!(ep.ctx, prologue_ep, prologue_env) {|ty, ep| }
-    end
-
-    Config.rbs_files.each do |rbs|
-      if rbs.is_a?(Array) # [String name, String content]
-        Import.import_rbs_code(scratch, *rbs)
-      else
-        Import.import_rbs_file(scratch, rbs)
-      end
+      scratch.add_entrypoint(iseq)
     end
 
     result = scratch.type_profile
@@ -100,6 +113,9 @@ module TypeProf
       end
     end
 
+  rescue TypeProfError => exc
+    exc.report(Config.output)
+
   ensure
     if Config.options[:stackprof] && defined?(StackProf)
       StackProf.stop

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
 
@@ -128,36 +137,53 @@ module TypeProf
             ctxs = @iseq_method_to_ctxs[mdef]
             next unless ctxs
 
-            ctxs.each do |ctx|
-              next if mid != ctx.mid
-              next if Config.check_dir_filter(ctx.iseq.absolute_path) == :exclude
+            ctx = ctxs.find {|ctx| ctx.mid == mid } || ctxs.first
 
-              method_name = ctx.mid
-              method_name = "self.#{ method_name }" if singleton
+            next if Config.check_dir_filter(ctx.iseq.absolute_path) == :exclude
 
-              iseq_methods[method_name] ||= [true, []]
-              iseq_methods[method_name][0] &&= mdef.pub_meth
-              iseq_methods[method_name][1] << @scratch.show_method_signature(ctx)
+            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)
+            (methods[key] ||= []) << @scratch.show_method_signature(ctx)
+          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 +194,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 +206,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 +218,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 +245,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 +282,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 +298,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 + 5) + "| ")
-        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 + 6) + "| ")
-        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