typeprof 0.2.0 → 0.5.0

data/lib/typeprof/builtin.rb

@@ -54,21 +54,29 @@ module TypeProf
       ctn[ret_ty, ep, env]
     end
 
+    def vmcore_raise(recv, mid, aargs, ep, env, scratch, &ctn)
+      # no-op
+    end
+
     def lambda(recv, mid, aargs, ep, env, scratch, &ctn)
       ctn[aargs.blk_ty, ep, env]
     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::ContainerType.create_empty_instance(recv)
+        env, ty = scratch.localize_type(ty, env, ep, AllocationSite.new(ep).add_id(:object_s_new))
+      else
+        ty = Type::Instance.new(recv)
+      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 +126,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,9 +146,8 @@ module TypeProf
         ctn[type.any, ep, env]
         return
       end
-      naargs = ActualArguments.new([recv], Type.nil, 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
@@ -244,7 +251,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)
@@ -256,7 +266,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
 
@@ -307,7 +317,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
 
@@ -316,14 +326,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 +345,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 +371,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 +379,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 +489,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
@@ -518,6 +525,7 @@ module TypeProf
       scratch.set_custom_method(klass_vmcore, :"core#set_method_alias", Builtin.method(:vmcore_set_method_alias))
       scratch.set_custom_method(klass_vmcore, :"core#undef_method", Builtin.method(:vmcore_undef_method))
       scratch.set_custom_method(klass_vmcore, :"core#hash_merge_kwd", Builtin.method(:vmcore_hash_merge_kwd))
+      scratch.set_custom_method(klass_vmcore, :"core#raise", Builtin.method(:vmcore_raise))
       scratch.set_custom_method(klass_vmcore, :lambda, Builtin.method(:lambda))
       scratch.set_singleton_custom_method(klass_obj, :"new", Builtin.method(:object_s_new))
       scratch.set_singleton_custom_method(klass_obj, :"attr_accessor", Builtin.method(:module_attr_accessor))
@@ -529,6 +537,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))
@@ -551,8 +560,10 @@ module TypeProf
       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))
+      # 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/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