typeprof 0.2.0 → 0.5.0

data/lib/typeprof/export.rb

@@ -25,6 +25,13 @@ 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]
@@ -74,136 +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
+      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
 
-      @class_defs.each_value do |class_def|
-        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 }
-          mod_def.name
-        end
+      @scratch.namespace = class_def.name
 
-        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
-
-                fargs = @sig_fargs[ctx]
-                ret_tys = @sig_ret[ctx]
-
-                iseq_methods[method_name] ||= []
-                iseq_methods[method_name] << @scratch.show_signature(fargs, @yields[ctx], ret_tys)
-              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
+      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
+
+      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
+
+      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
+
+      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 = 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 = 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
+      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
 
-        if !class_def.absolute_path || Config.check_dir_filter(class_def.absolute_path) == :exclude
-          next if included_mods.empty? && ivars.empty? && cvars.empty? && iseq_methods.empty? && attr_methods.empty?
-        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
 
-        output.puts unless first
-        first = false
+      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
 
-        if class_def.superclass
-          omit = @class_defs[class_def.superclass].klass_obj == Type::Builtin[:obj] || class_def.klass_obj == Type::Builtin[:obj]
-          superclass = omit ? "" : " < #{ @class_defs[class_def.superclass].name }"
-        end
+      @scratch.namespace = nil
 
-        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, rbs_declared|
-          s = rbs_declared ? "# " : "  "
-          output.puts s + "#{ var } : #{ ty }" unless var.start_with?("_")
-        end
-        cvars.each do |var, ty, rbs_declared|
-          s = rbs_declared ? "# " : "  "
-          output.puts s + "#{ 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.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
+
+    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|
@@ -212,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

data/lib/typeprof/import.rb

@@ -29,9 +29,10 @@ module TypeProf
     end
 
     def self.load_rbs(env, builtin: false, **opt)
-      loader = RBS::EnvironmentLoader.new
-      unless builtin
-        loader.no_builtin!
+      if builtin
+        loader = RBS::EnvironmentLoader.new
+      else
+        loader = RBS::EnvironmentLoader.new(core_root: nil)
         loader.add(**opt)
       end
       new_decls = loader.load(env: env)
@@ -89,12 +90,13 @@ module TypeProf
       json = {}
 
       each_class_decl do |name, decls|
-        super_class_name = get_super_class_name(name)
+        super_class_name = get_super_class_name(name, decls)
         klass = conv_type_name(name)
         superclass = super_class_name ? conv_type_name(super_class_name) : nil
 
         type_params = nil
         included_modules = []
+        extended_modules = []
         methods = {}
         ivars = {}
         cvars = {}
@@ -103,8 +105,6 @@ module TypeProf
         decls.each do |decl|
           decl = decl.decl
 
-          raise NotImplementedError if decl.is_a?(RBS::AST::Declarations::Interface) # XXX
-
           type_params2 = decl.type_params.params.map {|param| [param.name, param.variance] }
           raise "inconsistent type parameter declaration" if type_params && type_params != type_params2
           type_params = type_params2
@@ -160,6 +160,15 @@ module TypeProf
                 # including an interface is not supported yet
               end
 
+            when RBS::AST::Members::Extend
+              name = member.name
+              if name.kind == :class
+                mod = conv_type_name(name)
+                extended_modules << mod
+              else
+                # extending a module with an interface is not supported yet
+              end
+
             when RBS::AST::Members::InstanceVariable
               ivars[member.name] = conv_type(member.type)
             when RBS::AST::Members::ClassVariable
@@ -184,6 +193,7 @@ module TypeProf
           superclass: superclass,
           members: {
             included_modules: included_modules,
+            extended_modules: extended_modules,
             methods: methods,
             ivars: ivars,
             cvars: cvars,
@@ -196,13 +206,11 @@ module TypeProf
     end
 
     def each_class_decl
-      classes = []
-
       # topological sort
       #   * superclasses and modules appear earlier than their subclasses (Object is earlier than String)
       #   * namespace module appers earlier than its children (Process is earlier than Process::Status)
       visited = {}
-      queue = @cur_env.class_decls.keys.map {|name| [:visit, name] }
+      queue = @cur_env.class_decls.keys.map {|name| [:visit, name] }.reverse
       until queue.empty?
         event, name = queue.pop
         case event
@@ -223,7 +231,9 @@ module TypeProf
         end
       end
 
-      classes
+      @cur_env.interface_decls.each do |name, decl|
+        yield name, [decl]
+      end
     end
 
     def each_ancestor(decl, &blk)
@@ -236,15 +246,15 @@ module TypeProf
       end
     end
 
-    def get_super_class_name(name)
+    def get_super_class_name(name, decls)
       return nil if name == RBS::BuiltinNames::BasicObject.name
 
-      @all_env.class_decls[name].decls.each do |decl|
+      decls.each do |decl|
         decl = decl.decl
         case decl
         when RBS::AST::Declarations::Class
           return decl.super_class.name if decl.super_class
-        when RBS::AST::Declarations::Module
+        when RBS::AST::Declarations::Module, RBS::AST::Declarations::Interface
           return nil
         else
           raise "unknown declaration: %p" % decl.class
@@ -255,35 +265,38 @@ module TypeProf
     end
 
     def conv_method_def(rbs_method_types)
-      rbs_method_types.map do |type|
-        blk = type.block ? conv_block(type.block) : nil
-        type_params = type.type_params
-
-        lead_tys = type.type.required_positionals.map {|type| conv_type(type.type) }
-        opt_tys = type.type.optional_positionals.map {|type| conv_type(type.type) }
-        rest_ty = type.type.rest_positionals
-        rest_ty = conv_type(rest_ty.type) if rest_ty
-        opt_kw_tys = type.type.optional_keywords.to_h {|key, type| [key, conv_type(type.type)] }
-        req_kw_tys = type.type.required_keywords.to_h {|key, type| [key, conv_type(type.type)] }
-        rest_kw_ty = type.type.rest_keywords
-        raise NotImplementedError if rest_kw_ty # XXX
-
-        ret_ty = conv_type(type.type.return_type)
-
-        {
-          type_params: type_params,
-          lead_tys: lead_tys,
-          opt_tys: opt_tys,
-          rest_ty: rest_ty,
-          req_kw_tys: req_kw_tys,
-          opt_kw_tys: opt_kw_tys,
-          rest_kw_ty: rest_kw_ty,
-          blk: blk,
-          ret_ty: ret_ty,
-        }
+      rbs_method_types.map do |method_type|
+        conv_func(method_type.type_params, method_type.type, method_type.block)
       end
     end
 
+    def conv_func(type_params, func, block)
+      blk = block ? conv_block(block) : nil
+
+      lead_tys = func.required_positionals.map {|type| conv_type(type.type) }
+      opt_tys = func.optional_positionals.map {|type| conv_type(type.type) }
+      rest_ty = func.rest_positionals
+      rest_ty = conv_type(rest_ty.type) if rest_ty
+      opt_kw_tys = func.optional_keywords.to_h {|key, type| [key, conv_type(type.type)] }
+      req_kw_tys = func.required_keywords.to_h {|key, type| [key, conv_type(type.type)] }
+      rest_kw_ty = func.rest_keywords
+      raise NotImplementedError if rest_kw_ty # XXX
+
+      ret_ty = conv_type(func.return_type)
+
+      {
+        type_params: type_params,
+        lead_tys: lead_tys,
+        opt_tys: opt_tys,
+        rest_ty: rest_ty,
+        req_kw_tys: req_kw_tys,
+        opt_kw_tys: opt_kw_tys,
+        rest_kw_ty: rest_kw_ty,
+        blk: blk,
+        ret_ty: ret_ty,
+      }
+    end
+
     def attr_reader_def(ty)
       [{
         type_params: [],
@@ -320,6 +333,8 @@ module TypeProf
       raise NotImplementedError unless type.required_keywords.empty?
       raise NotImplementedError if type.rest_keywords
 
+      req = rbs_block.required
+
       lead_tys = type.required_positionals.map do |type|
         conv_type(type.type)
       end
@@ -329,7 +344,7 @@ module TypeProf
 
       ret_ty = conv_type(type.return_type)
 
-      [lead_tys, opt_tys, ret_ty]
+      [req, lead_tys, opt_tys, ret_ty]
     end
 
     def conv_type(ty)
@@ -350,11 +365,16 @@ module TypeProf
           raise if ty.args.size != 2
           [:array, [:Enumerator], [], conv_type(ty.args.first)]
         else
-          [:instance, klass]
+          if ty.args.empty?
+            [:instance, klass]
+          else
+            [:cell, [:instance, klass], ty.args.map {|ty| conv_type(ty) }]
+          end
         end
       when RBS::Types::Bases::Bool   then [:bool]
       when RBS::Types::Bases::Any    then [:any]
-      when RBS::Types::Bases::Void   then [:any]
+      when RBS::Types::Bases::Top    then [:any]
+      when RBS::Types::Bases::Void   then [:void]
       when RBS::Types::Bases::Self   then [:self]
       when RBS::Types::Bases::Nil    then [:nil]
       when RBS::Types::Bases::Bottom then [:union, []]
@@ -387,11 +407,13 @@ module TypeProf
         when "::_ToInt" then [:int]
         when "::_ToAry[U]" then [:array, [:Array], [], [:var, :U]]
         else
-          [:any]
+          [:instance, conv_type_name(ty.name)]
         end
       when RBS::Types::Bases::Instance then [:any] # XXX: not implemented yet
-      when RBS::Types::Record then [:any] # XXX: not implemented yet
-      when RBS::Types::Proc   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
+        [:proc, conv_func(nil, ty.type, nil)]
       else
         warn "unknown RBS type: %p" % ty.class
         [:any]
@@ -411,7 +433,7 @@ module TypeProf
     def self.import_library(scratch, feature)
       begin
         json = scratch.rbs_reader.load_library(feature)
-      rescue RBS::EnvironmentLoader::UnknownLibraryNameError
+      rescue RBS::EnvironmentLoader::UnknownLibraryError
         return nil
       end
       # need cache?
@@ -419,7 +441,8 @@ module TypeProf
     end
 
     def self.import_rbs_file(scratch, rbs_path)
-      Import.new(scratch, scratch.rbs_reader.load_path(Pathname(rbs_path))).import(true)
+      rbs_path = Pathname(rbs_path) unless rbs_path.is_a?(Pathname)
+      Import.new(scratch, scratch.rbs_reader.load_path(rbs_path)).import(true)
     end
 
     def initialize(scratch, json)
@@ -451,6 +474,7 @@ module TypeProf
           when [:Symbol]     then Type::Builtin[:sym]   = klass
           when [:Array]      then Type::Builtin[:ary]   = klass
           when [:Hash]       then Type::Builtin[:hash]  = klass
+          when [:Proc]       then Type::Builtin[:proc]  = klass
           end
         end
 
@@ -459,6 +483,7 @@ module TypeProf
 
       classes.each do |klass, members|
         included_modules = members[:included_modules]
+        extended_modules = members[:extended_modules]
         methods = members[:methods]
         ivars = members[:ivars]
         cvars = members[:cvars]
@@ -468,6 +493,10 @@ module TypeProf
           @scratch.include_module(klass, path_to_klass(mod), nil)
         end
 
+        extended_modules.each do |mod|
+          @scratch.extend_module(klass, path_to_klass(mod), nil)
+        end
+
         methods.each do |(singleton, method_name), mdef|
           rbs_source = explicit ? rbs_sources[[singleton, method_name]] : nil
           mdef = conv_method_def(method_name, mdef, rbs_source)
@@ -475,73 +504,86 @@ module TypeProf
         end
 
         ivars.each do |ivar_name, ty|
-          ty = conv_type(ty)
+          ty = conv_type(ty).remove_type_vars
           @scratch.add_ivar_write!(Type::Instance.new(klass), ivar_name, ty, nil)
         end
 
         cvars.each do |ivar_name, ty|
-          ty = conv_type(ty)
+          ty = conv_type(ty).remove_type_vars
           @scratch.add_cvar_write!(klass, ivar_name, ty, nil)
         end
       end
 
       @json[:constants].each do |classpath, value|
         base_klass = path_to_klass(classpath[0..-2])
-        value = conv_type(value)
-        @scratch.add_constant(base_klass, classpath[-1], value)
+        value = conv_type(value).remove_type_vars
+        @scratch.add_constant(base_klass, classpath[-1], value, nil)
       end
 
-      @json[:globals].each do |name, value|
-        @scratch.add_gvar_write!(name, conv_type(value), nil)
+      @json[:globals].each do |name, ty|
+        ty = conv_type(ty).remove_type_vars
+        @scratch.add_gvar_write!(name, ty, nil)
       end
 
       true
     end
 
     def conv_method_def(method_name, mdef, rbs_source)
-      sig_rets = mdef.map do |sig_ret|
-        #type_params = sig_ret[:type_params] # XXX
-        lead_tys = sig_ret[:lead_tys]
-        opt_tys = sig_ret[:opt_tys]
-        rest_ty = sig_ret[:rest_ty]
-        req_kw_tys = sig_ret[:req_kw_tys]
-        opt_kw_tys = sig_ret[:opt_kw_tys]
-        rest_kw_ty = sig_ret[:rest_kw_ty]
-        blk = sig_ret[:blk]
-        ret_ty = sig_ret[:ret_ty]
+      sig_rets = mdef.flat_map do |sig_ret|
+        conv_func(sig_ret)
+      end
 
-        lead_tys = lead_tys.map {|ty| conv_type(ty) }
-        opt_tys = opt_tys.map {|ty| conv_type(ty) }
-        rest_ty = conv_type(rest_ty) if rest_ty
-        kw_tys = []
-        req_kw_tys.each {|key, ty| kw_tys << [true, key, conv_type(ty)] }
-        opt_kw_tys.each {|key, ty| kw_tys << [false, key, conv_type(ty)] }
-        kw_rest_ty = conv_type(rest_kw_ty) if rest_kw_ty
-        blk = blk ? conv_block(blk) : Type.nil
-        fargs = FormalArguments.new(lead_tys, opt_tys, rest_ty, [], kw_tys, kw_rest_ty, blk)
+      TypedMethodDef.new(sig_rets, rbs_source)
+    end
+
+    def conv_func(sig_ret)
+      #type_params = sig_ret[:type_params] # XXX
+      lead_tys = sig_ret[:lead_tys]
+      opt_tys = sig_ret[:opt_tys]
+      rest_ty = sig_ret[:rest_ty]
+      req_kw_tys = sig_ret[:req_kw_tys]
+      opt_kw_tys = sig_ret[:opt_kw_tys]
+      rest_kw_ty = sig_ret[:rest_kw_ty]
+      blk = sig_ret[:blk]
+      ret_ty = sig_ret[:ret_ty]
 
-        ret_ty = conv_type(ret_ty)
+      lead_tys = lead_tys.map {|ty| conv_type(ty) }
+      opt_tys = opt_tys.map {|ty| conv_type(ty) }
+      rest_ty = conv_type(rest_ty) if rest_ty
+      kw_tys = []
+      req_kw_tys.each {|key, ty| kw_tys << [true, key, conv_type(ty)] }
+      opt_kw_tys.each {|key, ty| kw_tys << [false, key, conv_type(ty)] }
+      kw_rest_ty = conv_type(rest_kw_ty) if rest_kw_ty
 
-        [fargs, ret_ty]
-      end.compact
+      blks = conv_block(blk)
 
-      TypedMethodDef.new(sig_rets, rbs_source)
+      ret_ty = conv_type(ret_ty)
+
+      blks.map do |blk|
+        [MethodSignature.new(lead_tys, opt_tys, rest_ty, [], kw_tys, kw_rest_ty, blk), ret_ty]
+      end
     end
 
     def conv_block(blk)
-      lead_tys, opt_tys, ret_ty = blk
+      return [Type.nil] unless blk
+      req, lead_tys, opt_tys, ret_ty = blk
       lead_tys = lead_tys.map {|ty| conv_type(ty) }
       opt_tys = opt_tys.map {|ty| conv_type(ty) }
-      fargs = FormalArguments.new(lead_tys, opt_tys, nil, nil, nil, nil, nil)
+      msig = MethodSignature.new(lead_tys, opt_tys, nil, nil, nil, nil, nil)
       ret_ty = conv_type(ret_ty)
-      Type::TypedProc.new(fargs, ret_ty, Type::Builtin[:proc])
+      ret = [Type::Proc.new(TypedBlock.new(msig, ret_ty), Type::Builtin[:proc])]
+      ret << Type.nil unless req
+      ret
     end
 
     def conv_type(ty)
       case ty.first
       when :class then path_to_klass(ty[1])
       when :instance then Type::Instance.new(path_to_klass(ty[1]))
+      when :cell
+        Type::Cell.new(Type::Cell::Elements.new(ty[2].map {|ty| conv_type(ty) }), conv_type(ty[1]))
       when :any then Type.any
+      when :void then Type::Void.new
       when :nil then Type.nil
       when :optional then Type.optional(conv_type(ty[1]))
       when :bool then Type.bool
@@ -564,11 +606,23 @@ module TypeProf
           v_ty = conv_type(v)
           h[k_ty] = v_ty
         end
+      when :hash_record
+        _, path, key_tys = ty
+        Type.gen_hash(Type::Instance.new(path_to_klass(path))) do |h|
+          key_tys.each do |key, ty|
+            k_ty = Type::Symbol.new(key, Type::Instance.new(Type::Builtin[:sym]))
+            v_ty = conv_type(ty)
+            h[k_ty] = v_ty
+          end
+        end
       when :union
         tys = ty[1]
-        Type::Union.new(Utils::Set[*tys.map {|ty2| conv_type(ty2) }], nil) # XXX: Array and Hash support
+        Type::Union.new(Utils::Set[*tys.map {|ty2| conv_type(ty2) }], nil).normalize # XXX: Array and Hash support
       when :var
         Type::Var.new(ty[1])
+      when :proc
+        msig, ret_ty = conv_func(ty[1]).first # Currently, RBS Proc does not accept a block, so the size should be always one
+        Type::Proc.new(TypedBlock.new(msig, ret_ty), Type::Instance.new(Type::Builtin[:proc]))
       else
         pp ty
         raise NotImplementedError