typeprof 0.1.2 → 0.4.0

data/lib/typeprof/config.rb

@@ -0,0 +1,114 @@
+require "rbconfig"
+
+module TypeProf
+  ConfigData = Struct.new(
+    :rb_files,
+    :rbs_files,
+    :output,
+    :gem_rbs_features,
+    :verbose,
+    :dir_filter,
+    :max_iter,
+    :max_sec,
+    :options,
+    keyword_init: true
+  )
+
+  class ConfigData
+    def initialize(**opt)
+      opt[:output] ||= $stdout
+      opt[:gem_rbs_features] ||= []
+      opt[:dir_filter] ||= DEFAULT_DIR_FILTER
+      opt[:verbose] ||= 0
+      opt[:options] ||= {}
+      opt[:options] = {
+        type_depth_limit: 5,
+        pedantic_output: false,
+        show_errors: false,
+        stackprof: nil,
+      }.merge(opt[:options])
+      super(**opt)
+    end
+
+    def check_dir_filter(path)
+      dir_filter.reverse_each do |cond, dir|
+        return cond unless dir
+        return cond if path.start_with?(dir)
+      end
+    end
+
+    DEFAULT_DIR_FILTER = [
+      [:include],
+      [:exclude, RbConfig::CONFIG["prefix"]],
+      [:exclude, Gem.dir],
+      [:exclude, Gem.user_dir],
+    ]
+  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)
+    end
+    TypeProf.const_set(:Config, config)
+
+    if Config.options[:stackprof]
+      require "stackprof"
+      out = "typeprof-stackprof-#{ Config.options[:stackprof] }.dump"
+      StackProf.start(mode: Config.options[:stackprof], out: out, raw: true)
+    end
+
+    scratch = Scratch.new
+    Builtin.setup_initial_global_env(scratch)
+
+    Config.gem_rbs_features.each do |feature|
+      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(StaticEnv.new(:top, Type.nil, false), [], [], Utils::HashWrapper.new({}))
+
+    Config.rb_files.each do |file|
+      if file.respond_to?(:read)
+        iseq = ISeq.compile_str(file.read, file.to_s)
+      else
+        iseq = ISeq.compile(file)
+      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 |path|
+      Import.import_rbs_file(scratch, path)
+    end
+
+    result = scratch.type_profile
+
+    if Config.output.respond_to?(:write)
+      scratch.report(result, Config.output)
+    else
+      open(Config.output, "w") do |output|
+        scratch.report(result, output)
+      end
+    end
+
+  ensure
+    if Config.options[:stackprof] && defined?(StackProf)
+      StackProf.stop
+      StackProf.results
+    end
+  end
+
+  def self.starting_state(iseq)
+    cref = CRef.new(:bottom, Type::Builtin[:obj], false) # object
+    recv = Type::Instance.new(Type::Builtin[:obj])
+    ctx = Context.new(iseq, cref, nil)
+    ep = ExecutionPoint.new(ctx, 0, nil)
+    locals = [Type.nil] * iseq.locals.size
+    env = Env.new(StaticEnv.new(recv, Type.nil, false), locals, [], Utils::HashWrapper.new({}))
+
+    return ep, env
+  end
+end

data/lib/typeprof/container-type.rb

@@ -6,22 +6,197 @@ module TypeProf
       raise if !val.is_a?(Utils::StructuralEquality) && !val.is_a?(Integer) && !val.is_a?(Symbol)
       @val = val
       @parent = parent
-      @_hash ||= (@val.hash ^ @parent.hash)
     end
 
     attr_reader :val, :parent
 
-    def hash
-      @_hash
-    end
-
     def add_id(val)
       AllocationSite.new(val, self)
     end
   end
 
   class Type # or AbstractValue
-    # This is a type for global interface, e.g., TypedISeq.
+    # Cell, Array, and Hash are types for global interface, e.g., TypedISeq.
+    # Do not push such types to local environment, stack, etc.
+
+    # The most basic container type for default type parameter class
+    class Cell < Type
+      def initialize(elems, base_type)
+        raise if !elems.is_a?(Cell::Elements)
+        @elems = elems # Cell::Elements
+        raise unless base_type
+        @base_type = base_type
+      end
+
+      attr_reader :elems, :base_type
+
+      def inspect
+        "Type::Cell[#{ @elems.inspect }, base_type: #{ @base_type.inspect }]"
+      end
+
+      def screen_name(scratch)
+        str = @elems.screen_name(scratch)
+        if str.start_with?("*")
+          str = @base_type.screen_name(scratch) + str[1..]
+        end
+        str
+      end
+
+      def localize(env, alloc_site, depth)
+        return env, Type.any if depth <= 0
+        alloc_site = alloc_site.add_id(:cell)
+        env, elems = @elems.localize(env, alloc_site, depth)
+        env.deploy_type(LocalCell, alloc_site, elems, @base_type)
+      end
+
+      def limit_size(limit)
+        return Type.any if limit <= 0
+        Cell.new(@elems.limit_size(limit - 1), @base_type)
+      end
+
+      def get_method(mid, scratch)
+        raise
+      end
+
+      def consistent?(other, subst)
+        case other
+        when Type::Any then true
+        when Type::Var then other.add_subst!(self, subst)
+        when Type::Union
+          other.types.each do |ty2|
+            return true if consistent?(ty2, subst)
+          end
+          return false
+        when Type::Cell
+          @elems.size == other.elems.size &&
+            @base_type.consistent?(other.base_type, subst) &&
+            @elems.zip(other.elems).all? {|elem1, elem2| elem1..consistent?(elem2, subst) }
+        else
+          self == other
+        end
+      end
+
+      def substitute(subst, depth)
+        return Type.any if depth <= 0
+        elems = @elems.substitute(subst, depth)
+        Cell.new(elems, @base_type)
+      end
+
+      class Elements
+        include Utils::StructuralEquality
+
+        def initialize(elems)
+          @elems = elems
+        end
+
+        attr_reader :elems
+
+        def to_local_type(id, base_ty)
+          Type::LocalCell.new(id, base_ty)
+        end
+
+        def globalize(env, visited, depth)
+          Elements.new(@elems.map {|ty| ty.globalize(env, visited, depth) })
+        end
+
+        def localize(env, alloc_site, depth)
+          elems = @elems.map.with_index do |ty, i|
+            alloc_site2 = alloc_site.add_id(i)
+            env, ty = ty.localize(env, alloc_site2, depth)
+            ty
+          end
+          return env, Elements.new(elems)
+        end
+
+        def limit_size(limit)
+          Elements.new(@elems.map {|ty| ty.limit_size(limit) })
+        end
+
+        def screen_name(scratch)
+          "*[#{ @elems.map {|ty| ty.screen_name(scratch) }.join(", ") }]"
+        end
+
+        def pretty_print(q)
+          q.group(9, "Elements[", "]") do
+            q.seplist(@elems) do |elem|
+              q.pp elem
+            end
+          end
+        end
+
+        def consistent?(other, subst)
+          false if @elems.size != other.elems.size
+          @elems.zip(other.elems) do |ty0, ty1|
+            return false unless ty0.consistent?(ty1, subst)
+          end
+          return true
+        end
+
+        def substitute(subst, depth)
+          Elements.new(@elems.map {|ty| ty.substitute(subst, depth) })
+        end
+
+        def [](idx)
+          @elems[idx]
+        end
+
+        def update(idx, ty)
+          Elements.new(Utils.array_update(@elems, idx, @elems[idx].union(ty)))
+        end
+
+        def union(other)
+          return self if self == other
+          elems = []
+          @elems.zip(other.elems) do |ty0, ty1|
+            elems << ty0.union(ty1)
+          end
+          Elements.new(elems)
+        end
+      end
+    end
+
+    class LocalCell < Type
+      def initialize(id, base_type)
+        @id = id
+        raise unless base_type
+        @base_type = base_type
+      end
+
+      attr_reader :id, :base_type
+
+      def inspect
+        "Type::LocalCell[#{ @id }, base_type: #{ @base_type.inspect }]"
+      end
+
+      def screen_name(scratch)
+        #raise "LocalArray must not be included in signature"
+        "LocalCell!"
+      end
+
+      def globalize(env, visited, depth)
+        if visited[self] || depth <= 0
+          Type.any
+        else
+          visited[self] = true
+          elems = env.get_container_elem_types(@id)
+          if elems
+            elems = elems.globalize(env, visited, depth - 1)
+          else
+            elems = Cell::Elements.new([]) # XXX
+          end
+          Cell.new(elems, @base_type)
+        end
+      end
+
+      def get_method(mid, scratch)
+        @base_type.get_method(mid, scratch)
+      end
+
+      def consistent?(other, subst)
+        raise "must not be used"
+      end
+    end
+
     # Do not insert Array type to local environment, stack, etc.
     class Array < Type
       def initialize(elems, base_type)
@@ -29,7 +204,6 @@ module TypeProf
         @elems = elems # Array::Elements
         raise unless base_type
         @base_type = base_type
-        # XXX: need infinite recursion
       end
 
       attr_reader :elems, :base_type
@@ -47,18 +221,11 @@ module TypeProf
         str
       end
 
-      def globalize(env, visited, depth)
-        return Type.any if depth <= 0
-        elems = @elems.globalize(env, visited, depth - 1)
-        base_ty = @base_type.globalize(env, visited, depth - 1)
-        Array.new(elems, base_ty)
-      end
-
       def localize(env, alloc_site, depth)
         return env, Type.any if depth <= 0
         alloc_site = alloc_site.add_id(:ary)
         env, elems = @elems.localize(env, alloc_site, depth - 1)
-        env.deploy_array_type(alloc_site, elems, @base_type)
+        env.deploy_type(LocalArray, alloc_site, elems, @base_type)
       end
 
       def limit_size(limit)
@@ -78,6 +245,7 @@ module TypeProf
           other.types.each do |ty2|
             return true if consistent?(ty2, subst)
           end
+          return false
         when Type::Array
           @base_type.consistent?(other.base_type, subst) && @elems.consistent?(other.elems, subst)
         else
@@ -102,8 +270,7 @@ module TypeProf
 
         attr_reader :lead_tys, :rest_ty
 
-        def to_local_type(id)
-          base_ty = Type::Instance.new(Type::Builtin[:ary])
+        def to_local_type(id, base_ty)
           Type::LocalArray.new(id, base_ty)
         end
 
@@ -171,6 +338,11 @@ module TypeProf
           @lead_tys.inject(@rest_ty) {|ty1, ty2| ty1.union(ty2) } #.union(Type.nil) # is this needed?
         end
 
+        def squash_or_any
+          ty = squash
+          ty == Type.bot ? Type.any : ty
+        end
+
         def [](idx)
           if idx >= 0
             if idx < @lead_tys.size
@@ -365,18 +537,11 @@ module TypeProf
         @elems.screen_name(scratch)
       end
 
-      def globalize(env, visited, depth)
-        return Type.any if depth <= 0
-        elems = @elems.globalize(env, visited, depth - 1)
-        base_ty = @base_type.globalize(env, visited, depth - 1)
-        Hash.new(elems, base_ty)
-      end
-
       def localize(env, alloc_site, depth)
         return env, Type.any if depth <= 0
         alloc_site = alloc_site.add_id(:hash)
         env, elems = @elems.localize(env, alloc_site, depth - 1)
-        env.deploy_hash_type(alloc_site, elems, @base_type)
+        env.deploy_type(LocalHash, alloc_site, elems, @base_type)
       end
 
       def limit_size(limit)
@@ -396,6 +561,7 @@ module TypeProf
           other.types.each do |ty2|
             return true if consistent?(ty2, subst)
           end
+          return false
         when Type::Hash
           @base_type.consistent?(other.base_type, subst) && @elems.consistent?(other.elems, subst)
         else
@@ -427,8 +593,7 @@ module TypeProf
 
         attr_reader :map_tys
 
-        def to_local_type(id)
-          base_ty = Type::Instance.new(Type::Builtin[:hash])
+        def to_local_type(id, base_ty)
           Type::LocalHash.new(id, base_ty)
         end
 
@@ -579,6 +744,22 @@ module TypeProf
 
           Elements.new(map_tys)
         end
+
+        def to_keywords
+          kw_tys = {}
+          @map_tys.each do |key_ty, val_ty|
+            if key_ty.is_a?(Type::Symbol)
+              kw_tys[key_ty.sym] = val_ty
+            else
+              all_val_ty = Type.bot
+              @map_tys.each do |_key_ty, val_ty|
+                all_val_ty = all_val_ty.union(val_ty)
+              end
+              return { nil => all_val_ty }
+            end
+          end
+          kw_tys
+        end
       end
     end
 

data/lib/typeprof/export.rb

@@ -25,19 +25,26 @@ module TypeProf
       ntrace
     end
 
+    def show_message(terminated, output)
+      if terminated
+        output.puts "# CAUTION: Type profiling was terminated prematurely because of the limitation"
+        output.puts
+      end
+    end
+
     def show_error(errors, backward_edge, output)
       return if errors.empty?
       return unless Config.options[:show_errors]
 
       output.puts "# Errors"
       errors.each do |ep, msg|
-        if ENV["TYPE_PROFILER_DETAIL"]
+        if ENV["TP_DETAIL"]
           backtrace = filter_backtrace(generate_analysis_trace(ep, {}, backward_edge))
         else
           backtrace = [ep]
         end
         loc, *backtrace = backtrace.map do |ep|
-          ep.source_location
+          ep&.source_location
         end
         output.puts "#{ loc }: #{ msg }"
         backtrace.each do |loc|
@@ -57,13 +64,15 @@ module TypeProf
       output.puts
     end
 
-    def show_gvars(scratch, gvar_write, output)
+    def show_gvars(scratch, gvars, output)
       # A signature for global variables is not supported in RBS
-      return if gvar_write.empty?
+      return if gvars.dump.empty?
 
       output.puts "# Global variables"
-      gvar_write.each do |gvar_name, ty|
-        output.puts "#  #{ gvar_name } : #{ ty.screen_name(scratch) }"
+      gvars.dump.each do |gvar_name, entry|
+        next if entry.type == Type.bot
+        s = entry.rbs_declared ? "#" : ""
+        output.puts s + "#{ gvar_name } : #{ entry.type.screen_name(scratch) }"
       end
       output.puts
     end
@@ -72,122 +81,148 @@ module TypeProf
   class RubySignatureExporter
     def initialize(
       scratch,
-      class_defs, iseq_method_to_ctxs, sig_fargs, sig_ret, yields
+      class_defs, iseq_method_to_ctxs
     )
       @scratch = scratch
       @class_defs = class_defs
       @iseq_method_to_ctxs = iseq_method_to_ctxs
-      @sig_fargs = sig_fargs
-      @sig_ret = sig_ret
-      @yields = yields
     end
 
-    def show(stat_eps, output)
-      output.puts "# Classes" # and Modules
+    def conv_class(namespace, class_def, inner_classes)
+      @scratch.namespace = namespace
 
-      stat_classes = {}
-      stat_methods = {}
-      first = true
-      @class_defs.each_value do |class_def|
-        included_mods = class_def.modules[false].filter_map do |visible, mod_def|
-          mod_def.name if visible
-        end
+      if class_def.superclass
+        omit = @class_defs[class_def.superclass].klass_obj == Type::Builtin[:obj] || class_def.klass_obj == Type::Builtin[:obj]
+        superclass = omit ? nil : @scratch.get_class_name(@class_defs[class_def.superclass].klass_obj)
+      end
 
-        explicit_methods = {}
-        iseq_methods = {}
-        attr_methods = {}
-        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
+      @scratch.namespace = class_def.name
 
-              ctxs.each do |ctx|
-                next if mid != ctx.mid
+      consts = {}
+      class_def.consts.each do |name, (ty, absolute_path)|
+        next if ty.is_a?(Type::Class)
+        next if !absolute_path || Config.check_dir_filter(absolute_path) == :exclude
+        consts[name] = ty.screen_name(@scratch)
+      end
 
-                method_name = ctx.mid
-                method_name = "self.#{ method_name }" if singleton
+      included_mods = class_def.modules[false].filter_map do |mod_def, 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
 
-                fargs = @sig_fargs[ctx]
-                ret_tys = @sig_ret[ctx]
+      extended_mods = class_def.modules[true].filter_map do |mod_def, 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
 
-                iseq_methods[method_name] ||= []
-                iseq_methods[method_name] << @scratch.show_signature(fargs, @yields[ctx], ret_tys)
-              end
-            when AttrMethodDef
-              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
-                end
-              else
-                ty = class_def.ivars.write[[singleton, mdef.ivar]] || Type.any
-                attr_methods[method_name] = [mdef.kind, ty.screen_name(@scratch)]
-              end
-            when TypedMethodDef
-              if mdef.rbs_source
-                method_name, sigs = mdef.rbs_source
-                explicit_methods[method_name] = sigs
+      explicit_methods = {}
+      iseq_methods = {}
+      attr_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
+
+            ctxs.each do |ctx|
+              next if mid != ctx.mid
+              next if Config.check_dir_filter(ctx.iseq.absolute_path) == :exclude
+
+              method_name = ctx.mid
+              method_name = "self.#{ method_name }" if singleton
+
+              iseq_methods[method_name] ||= []
+              iseq_methods[method_name] << @scratch.show_method_signature(ctx)
+            end
+          when AttrMethodDef
+            next if Config.check_dir_filter(mdef.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
               end
+            else
+              entry = ivars[[singleton, mdef.ivar]]
+              ty = entry ? entry.type : Type.any
+              attr_methods[method_name] = [mdef.kind, ty.screen_name(@scratch)]
+            end
+          when TypedMethodDef
+            if mdef.rbs_source
+              method_name, sigs = mdef.rbs_source
+              explicit_methods[method_name] = sigs
             end
           end
         end
+      end
 
-        ivars = class_def.ivars.write.map do |(singleton, var), ty|
-          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]]
-          [var, ty.screen_name(@scratch)]
-        end.compact
+      ivars = ivars.map do |(singleton, var), entry|
+        next if entry.absolute_paths.all? {|path| Config.check_dir_filter(path) == :exclude }
+        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]]
+        [var, ty.screen_name(@scratch), entry.rbs_declared]
+      end.compact
 
-        cvars = class_def.cvars.write.map do |var, ty|
-          [var, ty.screen_name(@scratch)]
-        end
+      cvars = cvars.map do |var, entry|
+        next if entry.absolute_paths.all? {|path| Config.check_dir_filter(path) == :exclude }
+        [var, entry.type.screen_name(@scratch), entry.rbs_declared]
+      end
 
-        next if included_mods.empty? && ivars.empty? && cvars.empty? && iseq_methods.empty? && attr_methods.empty?
+      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?
+      end
 
-        output.puts unless first
-        first = false
+      @scratch.namespace = nil
 
-        if class_def.superclass
-          object = @class_defs[class_def.superclass].klass_obj == Type::Builtin[:obj]
-          superclass = object ? "" : " < #{ @class_defs[class_def.superclass].name }"
-        end
+      ClassData.new(
+        kind: class_def.kind,
+        name: class_def.name,
+        superclass: superclass,
+        consts: consts,
+        included_mods: included_mods,
+        extended_mods: extended_mods,
+        ivars: ivars,
+        cvars: cvars,
+        attr_methods: attr_methods,
+        explicit_methods: explicit_methods,
+        iseq_methods: iseq_methods,
+        inner_classes: inner_classes,
+      )
+    end
 
-        output.puts "#{ class_def.kind } #{ class_def.name }#{ superclass }"
-        included_mods.sort.each do |ty|
-          output.puts "  include #{ ty }"
-        end
-        ivars.each do |var, ty|
-          output.puts "  #{ var } : #{ ty }" unless var.start_with?("_")
-        end
-        cvars.each do |var, ty|
-          output.puts "  #{ var } : #{ ty }"
-        end
-        attr_methods.each do |(method_name, hidden), (kind, ty)|
-          output.puts "  attr_#{ kind } #{ method_name }#{ hidden ? "()" : "" } : #{ ty }"
-        end
-        explicit_methods.each do |method_name, sigs|
-          sigs = sigs.sort.join("\n" + "#" + " " * (method_name.size + 6) + "| ")
-          output.puts "# def #{ method_name } : #{ sigs }"
-        end
-        iseq_methods.each do |method_name, sigs|
-          sigs = sigs.sort.join("\n" + " " * (method_name.size + 7) + "| ")
-          output.puts "  def #{ method_name } : #{ sigs }"
+    ClassData = Struct.new(:kind, :name, :superclass, :consts, :included_mods, :extended_mods, :ivars, :cvars, :attr_methods, :explicit_methods, :iseq_methods, :inner_classes, keyword_init: true)
+
+    def show(stat_eps, output)
+      # make the class hierarchy
+      root = {}
+      @class_defs.each_value do |class_def|
+        h = root
+        class_def.name.each do |name|
+          h = h[name] ||= {}
         end
-        output.puts "end"
+        h[:class_def] = class_def
       end
 
+      hierarchy = build_class_hierarchy([], root)
+
+      output.puts "# Classes" # and Modules
+
+      show_class_hierarchy(0, hierarchy, output, true)
+
       if ENV["TP_STAT"]
-        output.puts "statistics:"
-        output.puts "  %d execution points" % stat_eps.size
-        output.puts "  %d classes" % stat_classes.size
-        output.puts "  %d methods (in total)" % stat_methods.size
+        output.puts ""
+        output.puts "# TypeProf statistics:"
+        output.puts "#   %d execution points" % stat_eps.size
       end
+
       if ENV["TP_COVERAGE"]
         coverage = {}
         stat_eps.each do |ep|
@@ -196,8 +231,78 @@ module TypeProf
           (coverage[path] ||= [])[lineno] ||= 0
           (coverage[path] ||= [])[lineno] += 1
         end
-        File.binwrite("coverage.dump", Marshal.dump(coverage))
+        File.binwrite("typeprof-analysis-coverage.dump", Marshal.dump(coverage))
+      end
+    end
+
+    def build_class_hierarchy(namespace, hierarchy)
+      hierarchy.map do |name, h|
+        class_def = h.delete(:class_def)
+        class_data = conv_class(namespace, class_def, build_class_hierarchy(namespace + [name], h))
+        class_data
+      end.compact
+    end
+
+    def show_class_hierarchy(depth, hierarchy, output, first)
+      hierarchy.each do |class_data|
+        output.puts unless first
+        first = false
+
+        show_class_data(depth, class_data, output)
+      end
+    end
+
+    def show_const(namespace, path)
+      return path.last.to_s if namespace == path
+      i = 0
+      i += 1 while namespace[i] && namespace[i] == path[i]
+      path[i..].join("::")
+    end
+
+    def show_class_data(depth, class_data, output)
+      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
+      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
+      end
+      class_data.extended_mods.sort.each do |mod|
+        output.puts indent + "  extend #{ mod }"
+        first = false
+      end
+      class_data.ivars.each do |var, ty, rbs_declared|
+        s = rbs_declared ? "# " : "  "
+        output.puts indent + s + "#{ var } : #{ ty }" unless var.start_with?("_")
+        first = false
+      end
+      class_data.cvars.each do |var, ty, rbs_declared|
+        s = rbs_declared ? "# " : "  "
+        output.puts indent + s + "#{ var } : #{ ty }"
+        first = false
+      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
+      class_data.iseq_methods.each do |method_name, sigs|
+        sigs = sigs.sort.join("\n" + indent + " " * (method_name.size + 7) + "| ")
+        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"
     end
   end
 end