typeprof 0.2.0 → 0.3.0

data/lib/typeprof/builtin.rb

@@ -65,10 +65,14 @@ module TypeProf
 
     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)
+        env, ty = scratch.localize_type(ty, env, ep, AllocationSite.new(ep).add_id(:object_s_new))
+      end
       meths = scratch.get_method(recv, false, :initialize)
       meths.flat_map do |meth|
         meth.do_send(ty, :initialize, aargs, ep, env, scratch) do |ret_ty, ep, env|
-          ctn[Type::Instance.new(recv), ep, env]
+          ctn[ty, ep, env]
         end
       end
     end
@@ -118,7 +122,7 @@ module TypeProf
       else
         mid_ty = aargs.rest_ty
       end
-      aargs = ActualArguments.new(aargs.lead_tys[1..-1], aargs.rest_ty, aargs.kw_ty, aargs.blk_ty)
+      aargs = ActualArguments.new(aargs.lead_tys[1..-1], aargs.rest_ty, aargs.kw_tys, aargs.blk_ty)
       found = false
       mid_ty.each_child do |mid|
         if mid.is_a?(Type::Symbol)
@@ -138,7 +142,7 @@ module TypeProf
         ctn[type.any, ep, env]
         return
       end
-      naargs = ActualArguments.new([recv], Type.nil, nil, Type.nil)
+      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|
         ctn[recv, ep, scratch.return_envs[ep]]
@@ -244,7 +248,10 @@ module TypeProf
     def array_aset(recv, mid, aargs, ep, env, scratch, &ctn)
       return ctn[Type.any, ep, env] unless recv.is_a?(Type::LocalArray)
 
-      raise NotImplementedError if aargs.lead_tys.size != 2
+      if aargs.lead_tys.size != 2
+        #raise NotImplementedError # XXX
+        ctn[Type.any, ep, env]
+      end
 
       idx = aargs.lead_tys.first
       if idx.is_a?(Type::Literal)
@@ -316,14 +323,12 @@ module TypeProf
 
     def struct_initialize(recv, mid, aargs, ep, env, scratch, &ctn)
       recv = Type::Instance.new(recv)
-      scratch.get_instance_variable(recv, :_members, ep, env) do |ty, nenv|
-        ty = scratch.globalize_type(ty, nenv, ep)
-        ty.elems.lead_tys.zip(aargs.lead_tys) do |sym, ty|
+      scratch.add_ivar_read!(recv, :_members, ep) do |member_ary_ty, ep|
+        member_ary_ty.elems.lead_tys.zip(aargs.lead_tys) do |sym, ty|
           ty ||= Type.nil
           scratch.set_instance_variable(recv, sym.sym, ty, ep, env)
         end
       end
-      #scratch.set_instance_variable(recv, , ty, ep, env)
       ctn[recv, ep, env]
     end
 
@@ -337,9 +342,8 @@ module TypeProf
         return
       end
       if struct_klass != recv
-        scratch.get_instance_variable(Type::Instance.new(struct_klass), :_members, ep, env) do |ty, nenv|
-          ty = scratch.globalize_type(ty, nenv, ep)
-          scratch.set_instance_variable(Type::Instance.new(recv), :_members, ty, ep, env)
+        scratch.add_ivar_read!(Type::Instance.new(struct_klass), :_members, ep) do |ty, ep|
+          scratch.add_ivar_write!(Type::Instance.new(recv), :_members, ty, ep)
         end
       end
       meths = scratch.get_method(recv, false, :initialize)
@@ -364,7 +368,7 @@ module TypeProf
       fields = fields.map {|field| Type::Symbol.new(field, Type::Instance.new(Type::Builtin[:sym])) }
       base_ty = Type::Instance.new(Type::Builtin[:ary])
       fields = Type::Array.new(Type::Array::Elements.new(fields), base_ty)
-      scratch.set_instance_variable(Type::Instance.new(struct_klass), :_members, fields, ep, env)
+      scratch.add_ivar_write!(Type::Instance.new(struct_klass), :_members, fields, ep)
       #set_singleton_custom_method(struct_klass, :members, Builtin.method(:...))
 
       ctn[struct_klass, ep, env]
@@ -372,10 +376,10 @@ module TypeProf
 
     def self.file_load(path, ep, env, scratch, &ctn)
       iseq = ISeq.compile(path)
-      callee_ep, callee_env = CLI.starting_state(iseq)
+      callee_ep, callee_env = TypeProf.starting_state(iseq)
       scratch.merge_env(callee_ep, callee_env)
 
-      scratch.add_callsite!(callee_ep.ctx, nil, ep, env) do |_ret_ty, ep|
+      scratch.add_callsite!(callee_ep.ctx, ep, env) do |_ret_ty, ep|
         ret_ty = Type::Instance.new(Type::Builtin[:true])
         ctn[ret_ty, ep, env]
       end
@@ -482,8 +486,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)
+      scratch.add_constant(klass_obj, :BasicObject, klass_basic_obj)
 
       Type::Builtin[:basic_obj] = klass_basic_obj
       Type::Builtin[:obj]   = klass_obj
@@ -550,9 +554,6 @@ 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))
-
-      fargs, ret_ty = FormalArguments.new([], [], nil, [], nil, nil, Type.any), Type.any
-      scratch.add_method(klass_obj, :initialize, false, TypedMethodDef.new([[fargs, ret_ty]], nil))
     end
   end
 end

data/lib/typeprof/cli.rb

@@ -1,64 +1,62 @@
 require "optparse"
-require "rbconfig"
 
 module TypeProf
-  class CLI
-    DEFAULT_DIR_FILTER = [
-      [:include],
-      [:exclude, RbConfig::CONFIG["prefix"]],
-      [:exclude, Gem.dir],
-      [:exclude, Gem.user_dir],
-    ]
+  module CLI
+    module_function
 
-    def initialize(argv)
+    def parse(argv)
       opt = OptionParser.new
 
-      @output = nil
+      output = nil
 
       # Verbose level:
       # * 0: no output
       # * 1: show indicator
       # * 2: debug print
-      @verbose = 1
-
-      @options = {
-        type_depth_limit: 5,
-        pedantic_output: false,
-        show_errors: false,
-      }
-      @dir_filter = nil
-      @rbs_features_to_load = []
-
-      opt.on("-o OUTFILE") {|v| @output = v }
-      opt.on("-q", "--quiet") { @verbose = 0 }
-      opt.on("-v", "--verbose") { @verbose = 2 }
+      verbose = 1
+
+      options = {}
+      dir_filter = nil
+      gem_rbs_features = []
+      version = false
+      max_sec = max_iter = nil
+
+      opt.on("-o OUTFILE") {|v| output = v }
+      opt.on("-q", "--quiet") { verbose = 0 }
+      opt.on("-v", "--verbose") { options[:show_errors] = true }
+      opt.on("--version") { version = true }
+      opt.on("-d", "--debug") { verbose = 2 }
       opt.on("-I DIR") {|v| $LOAD_PATH << v }
-      opt.on("-r FEATURE") {|v| @rbs_features_to_load << v }
+      opt.on("-r FEATURE") {|v| gem_rbs_features << v }
+      opt.on("--max-second SECOND", Float) {|v| max_sec = v }
+      opt.on("--max-iteration TIMES", Integer) {|v| max_iter = v }
 
       opt.on("--include-dir DIR") do |dir|
         # When `--include-dir` option is specified as the first directory option,
         # typeprof will exclude any files by default unless a file path matches the explicit option
-        @dir_filter ||= [[:exclude]]
-        @dir_filter << [:include, File.expand_path(dir)]
+        dir_filter ||= [[:exclude]]
+        dir_filter << [:include, File.expand_path(dir)]
       end
       opt.on("--exclude-dir DIR") do |dir|
         # When `--exclude-dir` option is specified as the first directory option,
         # typeprof will include any files by default, except Ruby's install directory and Gem directories
-        @dir_filter ||= DEFAULT_DIR_FILTER
-        @dir_filter << [:exclude, File.expand_path(dir)]
+        dir_filter ||= ConfigData::DEFAULT_DIR_FILTER
+        dir_filter << [:exclude, File.expand_path(dir)]
       end
 
       opt.on("-f OPTION") do |v|
         key, args = v.split("=", 2)
         case key
         when "type-depth-limit"
-          @options[:type_depth_limit] = Integer(args)
+          options[:type_depth_limit] = Integer(args)
         when "pedantic-output"
-          @options[:pedantic_output] = true
+          options[:pedantic_output] = true
         when "show-errors"
-          @options[:show_errors] = true
+          options[:show_errors] = true
         when "show-container-raw-elements"
-          @options[:show_container_raw_elements] = true
+          options[:show_container_raw_elements] = true
+        when "stackprof"
+          options[:stackprof] = args ? args.to_sym : :cpu
         else
           raise OptionParser::InvalidOption.new("unknown option: #{ key }")
         end
@@ -66,83 +64,38 @@ module TypeProf
 
       opt.parse!(argv)
 
-      @dir_filter ||= DEFAULT_DIR_FILTER
-      @rb_files = []
-      @rbs_files = []
+      dir_filter ||= ConfigData::DEFAULT_DIR_FILTER
+      rb_files = []
+      rbs_files = []
       argv.each do |path|
         if File.extname(path) == ".rbs"
-          @rbs_files << path
+          rbs_files << path
         else
-          @rb_files << path
+          rb_files << path
         end
       end
 
-      raise OptionParser::InvalidOption.new("no input files") if @rb_files.empty?
+      puts "typeprof #{ VERSION }" if version
+      if rb_files.empty?
+        exit if version
+        raise OptionParser::InvalidOption.new("no input files")
+      end
 
-      TypeProf.const_set(:Config, self)
+      ConfigData.new(
+        rb_files: rb_files,
+        rbs_files: rbs_files,
+        output: output,
+        gem_rbs_features: gem_rbs_features,
+        verbose: verbose,
+        dir_filter: dir_filter,
+        max_sec: max_sec,
+        max_iter: max_iter,
+        options: options,
+      )
 
     rescue OptionParser::InvalidOption
       puts $!
       exit
     end
-
-    attr_reader :verbose, :options, :dir_filter
-    attr_accessor :output
-
-    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
-
-    def run
-      scratch = Scratch.new
-      Builtin.setup_initial_global_env(scratch)
-
-      @rbs_features_to_load.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({}))
-
-      @rb_files.each do |path|
-        if path == "-"
-          iseq = ISeq.compile_str($<.read)
-        else
-          iseq = ISeq.compile(path)
-        end
-        ep, env = CLI.starting_state(iseq)
-        scratch.merge_env(ep, env)
-        scratch.add_callsite!(ep.ctx, nil, prologue_ep, prologue_env) {|ty, ep| }
-      end
-
-      @rbs_files.each do |path|
-        Import.import_rbs_file(scratch, path)
-      end
-
-      result = scratch.type_profile
-
-      if @output
-        open(@output, "w") do |output|
-          scratch.report(result, output)
-        end
-      else
-        scratch.report(result, $stdout)
-      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
 end

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,123 @@ 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)
+        @elems = elems # Array[Symbol]
+        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)
+        "#{ @base_type.screen_name(scratch) }[#{ @elems.map {|elem| elem.screen_name(scratch) }.join(", ") }]"
+      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)
+      end
+
+      def limit_size(limit)
+        return Type.any if limit <= 0
+        Cell.new(@elems.map {|elem| elem.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.map {|elem| elem.substitute(subst, depth - 1) }
+        Cell.new(elems, @base_type)
+      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.map {|elem| elem.globalize(env, visited, depth - 1) }
+          else
+            elems = [] # 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 +130,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,13 +147,6 @@ 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)
@@ -78,6 +171,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
@@ -365,13 +459,6 @@ 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)
@@ -396,6 +483,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
@@ -579,6 +667,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