typeprof 0.3.0 → 0.4.0

data/lib/typeprof/builtin.rb

@@ -59,14 +59,13 @@ module TypeProf
     end
 
     def proc_call(recv, mid, aargs, ep, env, scratch, &ctn)
-      given_block = env.static_env.blk_ty == recv
-      scratch.do_invoke_block(given_block, recv, aargs, ep, env, &ctn)
+      scratch.do_invoke_block(recv, aargs, ep, env, &ctn)
     end
 
     def object_s_new(recv, mid, aargs, ep, env, scratch, &ctn)
       ty = Type::Instance.new(recv)
       if recv.type_params.size >= 1
-        ty = Type::Cell.new([Type.bot] * recv.type_params.size, ty)
+        ty = Type::Cell.new(Type::Cell::Elements.new([Type.bot] * recv.type_params.size), ty)
         env, ty = scratch.localize_type(ty, env, ep, AllocationSite.new(ep).add_id(:object_s_new))
       end
       meths = scratch.get_method(recv, false, :initialize)
@@ -142,9 +141,8 @@ module TypeProf
         ctn[type.any, ep, env]
         return
       end
-      naargs = ActualArguments.new([recv], Type.nil, {}, Type.nil)
-      given_block = env.static_env.blk_ty == recv
-      scratch.do_invoke_block(given_block, aargs.blk_ty, naargs, ep, env, replace_recv_ty: recv) do |_ret_ty, ep|
+      naargs = ActualArguments.new([recv], nil, {}, Type.nil)
+      scratch.do_invoke_block(aargs.blk_ty, naargs, ep, env, replace_recv_ty: recv) do |_ret_ty, ep|
         ctn[recv, ep, scratch.return_envs[ep]]
       end
     end
@@ -263,7 +261,7 @@ module TypeProf
 
       ty = aargs.lead_tys.last
 
-      env = scratch.update_container_elem_types(env, ep, recv.id) do |elems|
+      env = scratch.update_container_elem_types(env, ep, recv.id, recv.base_type) do |elems|
         elems.update(idx, ty)
       end
 
@@ -314,7 +312,7 @@ module TypeProf
         return ctn[ty, ep, env]
       end
 
-      env = scratch.update_container_elem_types(env, ep, recv.id) do |elems|
+      env = scratch.update_container_elem_types(env, ep, recv.id, recv.base_type) do |elems|
         elems.update(idx, ty)
       end
 
@@ -486,8 +484,8 @@ module TypeProf
     def self.setup_initial_global_env(scratch)
       klass_basic_obj = scratch.new_class(nil, :BasicObject, [], :__root__, nil) # cbase, name, superclass
       klass_obj = scratch.new_class(nil, :Object, [], klass_basic_obj, nil)
-      scratch.add_constant(klass_obj, :Object, klass_obj)
-      scratch.add_constant(klass_obj, :BasicObject, klass_basic_obj)
+      scratch.add_constant(klass_obj, :Object, klass_obj, nil)
+      scratch.add_constant(klass_obj, :BasicObject, klass_basic_obj, nil)
 
       Type::Builtin[:basic_obj] = klass_basic_obj
       Type::Builtin[:obj]   = klass_obj
@@ -533,6 +531,7 @@ module TypeProf
       scratch.set_custom_method(klass_obj, :class, Builtin.method(:object_class))
       scratch.set_custom_method(klass_obj, :send, Builtin.method(:object_send))
       scratch.set_custom_method(klass_obj, :instance_eval, Builtin.method(:object_instance_eval))
+      scratch.set_custom_method(klass_obj, :proc, Builtin.method(:lambda))
 
       scratch.set_custom_method(klass_module, :include, Builtin.method(:module_include))
       scratch.set_custom_method(klass_module, :extend, Builtin.method(:module_extend))
@@ -554,6 +553,11 @@ module TypeProf
       scratch.set_custom_method(klass_obj, :require, Builtin.method(:kernel_require))
       scratch.set_custom_method(klass_obj, :require_relative, Builtin.method(:kernel_require_relative))
       scratch.set_custom_method(klass_obj, :Array, Builtin.method(:kernel_Array))
+
+      # ENV: Hash[String, String]
+      str_ty = Type::Instance.new(Type::Builtin[:str])
+      env_ty = Type.gen_hash {|h| h[str_ty] = Type.optional(str_ty) }
+      scratch.add_constant(klass_obj, :ENV, env_ty, false)
     end
   end
 end

data/lib/typeprof/container-type.rb

@@ -22,7 +22,8 @@ module TypeProf
     # The most basic container type for default type parameter class
     class Cell < Type
       def initialize(elems, base_type)
-        @elems = elems # Array[Symbol]
+        raise if !elems.is_a?(Cell::Elements)
+        @elems = elems # Cell::Elements
         raise unless base_type
         @base_type = base_type
       end
@@ -34,22 +35,23 @@ module TypeProf
       end
 
       def screen_name(scratch)
-        "#{ @base_type.screen_name(scratch) }[#{ @elems.map {|elem| elem.screen_name(scratch) }.join(", ") }]"
+        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)
-        elems = @elems.map.with_index do |elem, idx|
-          env, elem = elem.localize(env, alloc_site.add_id(idx), depth - 1)
-          elem
-        end
-        env.deploy_cell_type(alloc_site, elems, @base_type)
+        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.map {|elem| elem.limit_size(limit - 1) }, @base_type)
+        Cell.new(@elems.limit_size(limit - 1), @base_type)
       end
 
       def get_method(mid, scratch)
@@ -76,9 +78,81 @@ module TypeProf
 
       def substitute(subst, depth)
         return Type.any if depth <= 0
-        elems = @elems.map {|elem| elem.substitute(subst, depth - 1) }
+        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
@@ -106,9 +180,9 @@ module TypeProf
           visited[self] = true
           elems = env.get_container_elem_types(@id)
           if elems
-            elems = elems.map {|elem| elem.globalize(env, visited, depth - 1) }
+            elems = elems.globalize(env, visited, depth - 1)
           else
-            elems = [] # XXX
+            elems = Cell::Elements.new([]) # XXX
           end
           Cell.new(elems, @base_type)
         end
@@ -151,7 +225,7 @@ module TypeProf
         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)
@@ -196,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
 
@@ -265,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
@@ -463,7 +541,7 @@ module TypeProf
         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)
@@ -515,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
 

data/lib/typeprof/export.rb

@@ -81,141 +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
 
-      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
 
-        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 }
-          mod_def.name
-        end
+      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
 
-        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
+      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? && extended_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
-        extended_mods.sort.each do |ty|
-          output.puts "  extend #{ 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 ""
         output.puts "# TypeProf statistics:"
         output.puts "#   %d execution points" % stat_eps.size
       end
+
       if ENV["TP_COVERAGE"]
         coverage = {}
         stat_eps.each do |ep|
@@ -227,5 +234,75 @@ module TypeProf
         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