typeprof 0.2.0 → 0.3.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]
@@ -87,8 +94,6 @@ module TypeProf
     def show(stat_eps, output)
       output.puts "# Classes" # and Modules
 
-      stat_classes = {}
-      stat_methods = {}
       first = true
 
       @class_defs.each_value do |class_def|
@@ -97,6 +102,11 @@ module TypeProf
           mod_def.name
         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 }
+          mod_def.name
+        end
+
         explicit_methods = {}
         iseq_methods = {}
         attr_methods = {}
@@ -161,7 +171,7 @@ module TypeProf
         end
 
         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?
+          next if included_mods.empty? && extended_mods.empty? && ivars.empty? && cvars.empty? && iseq_methods.empty? && attr_methods.empty?
         end
 
         output.puts unless first
@@ -176,6 +186,9 @@ module TypeProf
         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?("_")
@@ -199,10 +212,9 @@ module TypeProf
       end
 
       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 = {}
@@ -212,7 +224,7 @@ 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
   end

data/lib/typeprof/import.rb

@@ -89,12 +89,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 +104,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 +159,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 +192,7 @@ module TypeProf
           superclass: superclass,
           members: {
             included_modules: included_modules,
+            extended_modules: extended_modules,
             methods: methods,
             ivars: ivars,
             cvars: cvars,
@@ -196,8 +205,6 @@ 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)
@@ -223,7 +230,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 +245,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
@@ -320,6 +329,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 +340,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)
@@ -354,7 +365,7 @@ module TypeProf
         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::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,7 +398,7 @@ 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
@@ -419,7 +430,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)
@@ -459,6 +471,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 +481,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)
@@ -499,7 +516,7 @@ module TypeProf
     end
 
     def conv_method_def(method_name, mdef, rbs_source)
-      sig_rets = mdef.map do |sig_ret|
+      sig_rets = mdef.flat_map do |sig_ret|
         #type_params = sig_ret[:type_params] # XXX
         lead_tys = sig_ret[:lead_tys]
         opt_tys = sig_ret[:opt_tys]
@@ -517,24 +534,29 @@ module TypeProf
         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)
+
+        blks = conv_block(blk)
 
         ret_ty = conv_type(ret_ty)
 
-        [fargs, ret_ty]
-      end.compact
+        blks.map do |blk|
+          [FormalArguments.new(lead_tys, opt_tys, rest_ty, [], kw_tys, kw_rest_ty, blk), ret_ty]
+        end
+      end
 
       TypedMethodDef.new(sig_rets, rbs_source)
     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)
       ret_ty = conv_type(ret_ty)
-      Type::TypedProc.new(fargs, ret_ty, Type::Builtin[:proc])
+      ret = [Type::TypedProc.new(fargs, ret_ty, Type::Builtin[:proc])]
+      ret << Type.nil unless req
+      ret
     end
 
     def conv_type(ty)
@@ -542,6 +564,7 @@ module TypeProf
       when :class then path_to_klass(ty[1])
       when :instance then Type::Instance.new(path_to_klass(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

data/lib/typeprof/iseq.rb

@@ -32,6 +32,22 @@ module TypeProf
         @name, @path, @absolute_path, @start_lineno, @type,
         @locals, @fargs_format, catch_table, insns = *iseq
 
+      if @type == :method
+        if @fargs_format[:opt]
+          label = @fargs_format[:opt].last
+          i = insns.index(label) + 1
+        else
+          i = insns.find_index {|insn| insn.is_a?(Array) }
+        end
+        # skip keyword initialization
+        while insns[i][0] == :checkkeyword
+          raise if insns[i + 1][0] != :branchif
+          label = insns[i + 1][1]
+          i = insns.index(label) + 1
+        end
+        insns[i, 0] = [[:_method_body]]
+      end
+
       @insns = []
       @linenos = []
 
@@ -79,7 +95,7 @@ module TypeProf
           nil
         when Array
           insn, *operands = e
-          operands = INSN_TABLE[insn].zip(operands).map do |type, operand|
+          operands = (INSN_TABLE[insn] || []).zip(operands).map do |type, operand|
             case type
             when "ISEQ"
               operand && ISeq.new(operand)

data/lib/typeprof/method.rb

@@ -24,7 +24,7 @@ module TypeProf
         callee_ep = do_send_core(fargs, start_pc, recv, mid, scratch)
 
         scratch.add_iseq_method_call!(self, callee_ep.ctx)
-        scratch.add_callsite!(callee_ep.ctx, fargs, caller_ep, caller_env, &ctn)
+        scratch.add_callsite!(callee_ep.ctx, caller_ep, caller_env, &ctn)
       end
     end
 
@@ -34,6 +34,7 @@ module TypeProf
       rest_start = @iseq.fargs_format[:rest_start]
       kw_start = @iseq.fargs_format[:kwbits]
       kw_start -= @iseq.fargs_format[:keyword].size if kw_start
+      kw_rest = @iseq.fargs_format[:kwrest]
       block_start = @iseq.fargs_format[:block_start]
 
       # XXX: need to check .rbs fargs and .rb fargs
@@ -72,13 +73,18 @@ module TypeProf
         end
       end
       if fargs.kw_tys
-        fargs.kw_tys.each_with_index do |(_, _, ty), i|
-          alloc_site2 = alloc_site.add_id(idx += 1)
+        fargs.kw_tys.each_with_index do |(_, key, ty), i|
+          alloc_site2 = alloc_site.add_id(key)
           nenv, ty = ty.localize(nenv, alloc_site2, Config.options[:type_depth_limit])
           nenv = nenv.local_update(kw_start + i, ty)
         end
       end
-      # kwrest
+      if fargs.kw_rest_ty
+        ty = fargs.kw_rest_ty
+        alloc_site2 = alloc_site.add_id(:**)
+        nenv, ty = ty.localize(nenv, alloc_site2, Config.options[:type_depth_limit])
+        nenv = nenv.local_update(kw_rest, ty)
+      end
       nenv = nenv.local_update(block_start, fargs.blk_ty) if block_start
 
       scratch.merge_env(callee_ep, nenv)
@@ -158,18 +164,36 @@ module TypeProf
         # XXX: support self type in fargs
         subst = { Type::Var.new(:self) => recv }
         next unless aargs.consistent_with_formal_arguments?(fargs, subst)
-        if recv.is_a?(Type::Array) && recv_orig.is_a?(Type::LocalArray)
+        case
+        when recv.is_a?(Type::Cell) && recv_orig.is_a?(Type::LocalCell)
+          tyvars = recv.base_type.klass.type_params.map {|name,| Type::Var.new(name) }
+          tyvars.each_with_index do |tyvar, idx|
+            ty = subst[tyvar]
+            if ty
+              ncaller_env, ty = scratch.localize_type(ty, ncaller_env, caller_ep)
+              ncaller_env = scratch.update_container_elem_types(ncaller_env, caller_ep, recv_orig.id) do |elems|
+                Utils.array_update(elems, idx, elems[idx].union(ty))
+              end
+            end
+          end
+          tyvars.zip(recv.elems) do |tyvar, elem|
+            if subst[tyvar]
+              subst[tyvar] = subst[tyvar].union(elem)
+            else
+              subst[tyvar] = elem
+            end
+          end
+        when recv.is_a?(Type::Array) && recv_orig.is_a?(Type::LocalArray)
           tyvar_elem = Type::Var.new(:Elem)
           if subst[tyvar_elem]
             ty = subst[tyvar_elem]
-            alloc_site = AllocationSite.new(caller_ep).add_id(self)
             ncaller_env, ty = scratch.localize_type(ty, ncaller_env, caller_ep)
             ncaller_env = scratch.update_container_elem_types(ncaller_env, caller_ep, recv_orig.id) do |elems|
               elems.update(nil, ty)
             end
           end
           subst.merge!({ tyvar_elem => recv.elems.squash })
-        elsif recv.is_a?(Type::Hash) && recv_orig.is_a?(Type::LocalHash)
+        when recv.is_a?(Type::Hash) && recv_orig.is_a?(Type::LocalHash)
           tyvar_k = Type::Var.new(:K)
           tyvar_v = Type::Var.new(:V)
           # XXX: need to support destructive operation
@@ -184,7 +208,7 @@ module TypeProf
           dummy_ep = ExecutionPoint.new(dummy_ctx, -1, caller_ep)
           dummy_env = Env.new(StaticEnv.new(recv, fargs.blk_ty, false), [], [], Utils::HashWrapper.new({}))
           if fargs.blk_ty.is_a?(Type::TypedProc)
-            scratch.add_callsite!(dummy_ctx, nil, caller_ep, ncaller_env, &ctn)
+            scratch.add_callsite!(dummy_ctx, caller_ep, ncaller_env, &ctn)
             nfargs = fargs.blk_ty.fargs
             alloc_site = AllocationSite.new(caller_ep).add_id(self)
             nlead_tys = (nfargs.lead_tys + nfargs.opt_tys).map.with_index do |ty, i|
@@ -200,7 +224,7 @@ module TypeProf
               ty
             end
             0.upto(nfargs.opt_tys.size) do |n|
-              naargs = ActualArguments.new(nlead_tys[0, nfargs.lead_tys.size + n], nil, nil, Type.nil) # XXX: support block to block?
+              naargs = ActualArguments.new(nlead_tys[0, nfargs.lead_tys.size + n], nil, {}, Type.nil) # XXX: support block to block?
               scratch.do_invoke_block(false, aargs.blk_ty, naargs, dummy_ep, dummy_env) do |blk_ret_ty, _ep, _env|
                 subst2 = {}
                 if blk_ret_ty.consistent?(fargs.blk_ty.ret_ty, subst2)

data/lib/typeprof/type.rb

@@ -3,7 +3,7 @@ module TypeProf
     include Utils::StructuralEquality
 
     def initialize
-      raise "cannot instanciate abstract type"
+      raise "cannot instantiate abstract type"
     end
 
     Builtin = {}
@@ -129,6 +129,17 @@ module TypeProf
       end
     end
 
+    class Void < Any
+      def inspect
+        "Type::Void"
+      end
+
+      def screen_name(scratch)
+        "void"
+      end
+    end
+
+
     class Union < Type
       def initialize(tys, elems)
         raise unless tys.is_a?(Utils::Set)
@@ -810,8 +821,6 @@ module TypeProf
           raise if !!kws1[kw] != !!kws2[kw]
         end
       elsif @kw_tys || other.kw_tys
-        puts
-        p self, other
         (@kw_tys || other.kw_tys).each do |req,|
           raise if req
         end
@@ -865,15 +874,16 @@ module TypeProf
 
   # Arguments from caller side
   class ActualArguments
-    def initialize(lead_tys, rest_ty, kw_ty, blk_ty)
+    def initialize(lead_tys, rest_ty, kw_tys, blk_ty)
       @lead_tys = lead_tys
       @rest_ty = rest_ty
-      @kw_ty = kw_ty
+      @kw_tys = kw_tys # kw_tys should be {:key1 => Type.bool, :key2 => Type.bool, ...} or {nil => Type.bool}
+      raise if !kw_tys.is_a?(::Hash)
       @blk_ty = blk_ty
       raise unless blk_ty
     end
 
-    attr_reader :lead_tys, :rest_ty, :kw_ty, :blk_ty
+    attr_reader :lead_tys, :rest_ty, :kw_tys, :blk_ty
 
     def merge(aargs)
       len = [@lead_tys.size, aargs.lead_tys.size].min
@@ -886,16 +896,25 @@ module TypeProf
         rest_ty = rest_ty.union(ty)
       end
       rest_ty = nil if rest_ty == Type.bot
-      #kw_ty = @kw_ty.union(aargs.kw_ty) # TODO
+      kw_tys = @kw_tys.dup
+      aargs.kw_tys.each do |sym, ty|
+        if kw_tys[sym]
+          kw_tys[sym] = kw_tys[sym].union(ty)
+        else
+          kw_tys[sym] = ty
+        end
+      end
       blk_ty = @blk_ty.union(aargs.blk_ty)
-      ActualArguments.new(lead_tys, rest_ty, kw_ty, blk_ty)
+      ActualArguments.new(lead_tys, rest_ty, kw_tys, blk_ty)
     end
 
     def globalize(caller_env, visited, depth)
       lead_tys = @lead_tys.map {|ty| ty.globalize(caller_env, visited, depth) }
       rest_ty = @rest_ty.globalize(caller_env, visited, depth) if @rest_ty
-      kw_ty = @kw_ty.globalize(caller_env, visited, depth) if @kw_ty
-      ActualArguments.new(lead_tys, rest_ty, kw_ty, @blk_ty)
+      kw_tys = @kw_tys.to_h do |key, ty|
+        [key, ty.globalize(caller_env, visited, depth)]
+      end
+      ActualArguments.new(lead_tys, rest_ty, kw_tys, @blk_ty)
     end
 
     def limit_size(limit)
@@ -942,6 +961,7 @@ module TypeProf
         lower_bound = upper_bound = 0
       end
 
+      a_kw_tys = @kw_tys.dup
       if keyword
         kw_tys = []
         keyword.each do |kw|
@@ -959,14 +979,12 @@ module TypeProf
             req = false
           end
 
-          sym = Type::Symbol.new(key, Type::Instance.new(Type::Builtin[:sym]))
-          ty = Type.bot
-          if @kw_ty.is_a?(Type::Hash)
-            # XXX: consider Union
-            ty = @kw_ty.elems[sym]
-            # XXX: remove the key
+          if a_kw_tys.key?(key)
+            ty = a_kw_tys.delete(key)
+          else
+            ty = a_kw_tys[nil] || Type.bot
           end
-          if ty == Type.bot
+          if ty == Type.bot && req
             yield "no argument for required keywords"
             return
           end
@@ -975,12 +993,18 @@ module TypeProf
         end
       end
       if kw_rest_acceptable
-        kw_rest_ty = @kw_ty
-        if kw_rest_ty == Type.any
-          kw_rest_ty = Type.gen_hash {|h| h[Type.any] = Type.any }
+        if a_kw_tys.key?(nil)
+          kw_rest_ty = Type.gen_hash {|h| h[Type.any] = a_kw_tys[nil] }
+        else
+          kw_rest_ty = Type.gen_hash do |h|
+            a_kw_tys.each do |key, ty|
+              sym = Type::Symbol.new(key, Type::Instance.new(Type::Builtin[:sym]))
+              h[sym] = ty
+            end
+          end
         end
       end
-      #if @kw_ty
+      #if @kw_tys
       #  yield "passed a keyword to non-keyword method"
       #end
 
@@ -1023,7 +1047,7 @@ module TypeProf
         lower_bound = [0, fargs.lead_tys.size + fargs.post_tys.size - aargs.size].max
         upper_bound = [0, lower_bound + fargs.opt_tys.size].max
         (lower_bound..upper_bound).each do |n|
-          tmp_aargs = ActualArguments.new(@lead_tys + [@rest_ty] * n, nil, @kw_ty, @blk_ty)
+          tmp_aargs = ActualArguments.new(@lead_tys + [@rest_ty] * n, nil, @kw_tys, @blk_ty)
           if tmp_aargs.consistent_with_formal_arguments?(fargs, subst)
             return true
           end
@@ -1078,8 +1102,12 @@ module TypeProf
       if @rest_ty
         aargs << ("*" + @rest_ty.screen_name(scratch))
       end
-      if @kw_ty
-        aargs << ("**" + @kw_ty.screen_name(scratch)) # TODO: Hash notation -> keyword notation
+      if @kw_tys.key?(nil)
+        aargs << "(unknown key): #{ @kw_tys[nil].screen_name(scratch) }"
+      else
+        @kw_tys.sort.each do |key, ty|
+          aargs << "#{ key }: #{ ty.screen_name(scratch) }"
+        end
       end
       s = "(#{ aargs.join(", ") })"
       s << " { #{ scratch.proc_screen_name(@blk_ty) } }" if @blk_ty != Type.nil