typeprof 0.1.2 → 0.4.0

data/lib/typeprof/builtin.rb

@@ -59,16 +59,19 @@ 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::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)
       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 +121,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,16 +141,15 @@ 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
 
     def module_include(recv, mid, aargs, ep, env, scratch, &ctn)
       arg = aargs.lead_tys[0]
-      scratch.include_module(recv, arg)
+      scratch.include_module(recv, arg, ep.ctx.iseq.absolute_path)
       ctn[recv, ep, env]
     end
 
@@ -155,7 +157,7 @@ module TypeProf
       arg = aargs.lead_tys[0]
       arg.each_child do |arg|
         if arg.is_a?(Type::Class)
-          scratch.extend_module(recv, arg)
+          scratch.extend_module(recv, arg, ep.ctx.iseq.absolute_path)
         end
       end
       ctn[recv, ep, env]
@@ -180,7 +182,7 @@ module TypeProf
       aargs.lead_tys.each do |aarg|
         sym = get_sym("attr_accessor", aarg, ep, scratch) or next
         cref = ep.ctx.cref
-        scratch.add_attr_method(cref.klass, sym, :"@#{ sym }", :accessor)
+        scratch.add_attr_method(cref.klass, ep.ctx.iseq.absolute_path, sym, :"@#{ sym }", :accessor)
       end
       ctn[Type.nil, ep, env]
     end
@@ -189,7 +191,7 @@ module TypeProf
       aargs.lead_tys.each do |aarg|
         sym = get_sym("attr_reader", aarg, ep, scratch) or next
         cref = ep.ctx.cref
-        scratch.add_attr_method(cref.klass, sym, :"@#{ sym }", :reader)
+        scratch.add_attr_method(cref.klass, ep.ctx.iseq.absolute_path, sym, :"@#{ sym }", :reader)
       end
       ctn[Type.nil, ep, env]
     end
@@ -198,7 +200,7 @@ module TypeProf
       aargs.lead_tys.each do |aarg|
         sym = get_sym("attr_writer", aarg, ep, scratch) or next
         cref = ep.ctx.cref
-        scratch.add_attr_method(cref.klass, sym, :"@#{ sym }", :writer)
+        scratch.add_attr_method(cref.klass, ep.ctx.iseq.absolute_path, sym, :"@#{ sym }", :writer)
       end
       ctn[Type.nil, ep, env]
     end
@@ -244,7 +246,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 +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
 
@@ -283,8 +288,6 @@ module TypeProf
         return
       end
       idx = aargs.lead_tys.first
-      #idx = scratch.globalize_type(idx, env, ep)
-      # XXX: recv may be a union
       recv.each_child do |recv|
         if recv.is_a?(Type::LocalHash)
           ty = scratch.get_hash_elem_type(env, ep, recv.id, idx)
@@ -309,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
 
@@ -318,14 +321,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
 
@@ -339,9 +340,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)
@@ -358,76 +358,85 @@ module TypeProf
       fields = aargs.lead_tys.map {|ty| get_sym("Struct.new", ty, ep, scratch) }.compact
       struct_klass = scratch.new_struct(ep)
 
-      scratch.add_singleton_custom_method(struct_klass, :new, Builtin.method(:struct_i_new))
-      scratch.add_singleton_custom_method(struct_klass, :[], Builtin.method(:struct_i_new))
+      scratch.set_singleton_custom_method(struct_klass, :new, Builtin.method(:struct_i_new))
+      scratch.set_singleton_custom_method(struct_klass, :[], Builtin.method(:struct_i_new))
       fields.each do |field|
-        scratch.add_attr_method(struct_klass, field, field, :accessor)
+        scratch.add_attr_method(struct_klass, ep.ctx.iseq.absolute_path, field, field, :accessor)
       end
       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)
-      #add_singleton_custom_method(struct_klass, :members, Builtin.method(:...))
+      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]
     end
 
-    def file_load(path, ep, env, scratch, &ctn)
+    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
     end
 
+    def self.file_require(feature, scratch)
+      return :done, :false if scratch.loaded_features[feature]
+      scratch.loaded_features[feature] = true
+
+      # XXX: dynamic RBS load is really needed??  Another idea:
+      #
+      # * RBS should be loaded in advance of analysis
+      # * require "some_gem/foo" should be ignored
+      # * require "app/foo" should always load .rb file (in this case, app/foo.rb)
+      return :done, :true if Import.import_library(scratch, feature)
+
+      # Try to analyze the source code of the gem
+      begin
+        gem feature
+      rescue Gem::MissingSpecError, Gem::LoadError
+      end
+
+      begin
+        filetype, path = $LOAD_PATH.resolve_feature_path(feature)
+        if filetype == :rb
+          return :do, path if File.readable?(path)
+
+          return :error, "failed to load: #{ path }"
+        else
+          return :error, "cannot load a .so file: #{ path }"
+        end
+      rescue LoadError
+        return :error, "failed to require: #{ feature }"
+      end
+    end
+
     def kernel_require(recv, mid, aargs, ep, env, scratch, &ctn)
       raise NotImplementedError if aargs.lead_tys.size != 1
       feature = aargs.lead_tys.first
       if feature.is_a?(Type::Literal)
         feature = feature.lit
 
-        begin
-          if scratch.loaded_features[feature]
-            result = Type::Instance.new(Type::Builtin[:false])
-            return ctn[result, ep, env]
-          end
-          scratch.loaded_features[feature] = true
-
-          # XXX: dynamic RBS load is really needed??  Another idea:
-          #
-          # * RBS should be loaded in advance of analysis
-          # * require "some_gem/foo" should be ignored
-          # * require "app/foo" should always load .rb file (in this case, app/foo.rb)
-          if RubySignatureImporter.import_library(scratch, feature)
-            result = Type::Instance.new(Type::Builtin[:true])
-            return ctn[result, ep, env]
-          end
-
-          begin
-            gem feature
-          rescue Gem::MissingSpecError, Gem::LoadError
-          end
-          filetype, path = $LOAD_PATH.resolve_feature_path(feature)
-          if filetype == :rb
-            # TODO: if there is RBS file for the library, do not read the source code
-            return file_load(path, ep, env, scratch, &ctn) if File.readable?(path)
-
-            scratch.warn(ep, "failed to load: #{ path }")
-          else
-            scratch.warn(ep, "cannot load a .so file: #{ path }")
-          end
-        rescue LoadError
-          scratch.warn(ep, "failed to require: #{ feature }")
+        action, arg = Builtin.file_require(feature, scratch)
+        case action
+        when :do
+          Builtin.file_load(arg, ep, env, scratch, &ctn)
+        when :done
+          result = Type::Instance.new(Type::Builtin[arg])
+          ctn[result, ep, env]
+        when :error
+          scratch.warn(ep, arg)
+          result = Type::Instance.new(Type.bool)
+          ctn[result, ep, env]
         end
       else
         scratch.warn(ep, "require target cannot be identified statically")
+        result = Type::Instance.new(Type.bool)
+        ctn[result, ep, env]
       end
-
-      result = Type::Instance.new(Type::Builtin[:true])
-      ctn[result, ep, env]
     end
 
     def kernel_require_relative(recv, mid, aargs, ep, env, scratch, &ctn)
@@ -443,7 +452,7 @@ module TypeProf
         scratch.loaded_features[feature] = true
 
         path = File.join(File.dirname(ep.ctx.iseq.path), feature) + ".rb" # XXX
-        return file_load(path, ep, env, scratch, &ctn) if File.readable?(path)
+        return Builtin.file_load(path, ep, env, scratch, &ctn) if File.readable?(path)
 
         scratch.warn(ep, "failed to load: #{ path }")
       else
@@ -473,20 +482,17 @@ module TypeProf
     end
 
     def self.setup_initial_global_env(scratch)
-      klass_obj = scratch.new_class(nil, :Object, [], :__root__) # cbase, name, superclass
-      scratch.add_constant(klass_obj, "Object", klass_obj)
-      klass_true  = scratch.new_class(klass_obj, :TrueClass, [], klass_obj) # ???
-      klass_false = scratch.new_class(klass_obj, :FalseClass, [], klass_obj) # ???
-      klass_nil = scratch.new_class(klass_obj, :NilClass, [], klass_obj) # ???
+      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, nil)
+      scratch.add_constant(klass_obj, :BasicObject, klass_basic_obj, nil)
 
+      Type::Builtin[:basic_obj] = klass_basic_obj
       Type::Builtin[:obj]   = klass_obj
-      Type::Builtin[:true]  = klass_true
-      Type::Builtin[:false] = klass_false
-      Type::Builtin[:nil]   = klass_nil
 
-      RubySignatureImporter.import_builtin(scratch)
+      Import.import_builtin(scratch)
 
-      Type::Builtin[:vmcore]    = scratch.new_class(klass_obj, :VMCore, [], klass_obj)
+      Type::Builtin[:vmcore]    = scratch.new_class(klass_obj, :VMCore, [], klass_obj, nil)
       Type::Builtin[:int]       = scratch.get_constant(klass_obj, :Integer)
       Type::Builtin[:float]     = scratch.get_constant(klass_obj, :Float)
       Type::Builtin[:rational]  = scratch.get_constant(klass_obj, :Rational)
@@ -511,44 +517,47 @@ module TypeProf
       klass_proc   = Type::Builtin[:proc]
       klass_module = Type::Builtin[:module]
 
-      scratch.add_custom_method(klass_vmcore, :"core#set_method_alias", Builtin.method(:vmcore_set_method_alias))
-      scratch.add_custom_method(klass_vmcore, :"core#undef_method", Builtin.method(:vmcore_undef_method))
-      scratch.add_custom_method(klass_vmcore, :"core#hash_merge_kwd", Builtin.method(:vmcore_hash_merge_kwd))
-      scratch.add_custom_method(klass_vmcore, :lambda, Builtin.method(:lambda))
-      scratch.add_singleton_custom_method(klass_obj, :"new", Builtin.method(:object_s_new))
-      scratch.add_singleton_custom_method(klass_obj, :"attr_accessor", Builtin.method(:module_attr_accessor))
-      scratch.add_singleton_custom_method(klass_obj, :"attr_reader", Builtin.method(:module_attr_reader))
-      scratch.add_singleton_custom_method(klass_obj, :"attr_writer", Builtin.method(:module_attr_writer))
-      scratch.add_custom_method(klass_obj, :p, Builtin.method(:kernel_p))
-      scratch.add_custom_method(klass_obj, :is_a?, Builtin.method(:object_is_a?))
-      scratch.add_custom_method(klass_obj, :respond_to?, Builtin.method(:object_respond_to?))
-      scratch.add_custom_method(klass_obj, :class, Builtin.method(:object_class))
-      scratch.add_custom_method(klass_obj, :send, Builtin.method(:object_send))
-      scratch.add_custom_method(klass_obj, :instance_eval, Builtin.method(:object_instance_eval))
-
-      scratch.add_custom_method(klass_module, :include, Builtin.method(:module_include))
-      scratch.add_custom_method(klass_module, :extend, Builtin.method(:module_extend))
-      scratch.add_custom_method(klass_module, :module_function, Builtin.method(:module_module_function))
-
-      scratch.add_custom_method(klass_proc, :[], Builtin.method(:proc_call))
-      scratch.add_custom_method(klass_proc, :call, Builtin.method(:proc_call))
-
-      scratch.add_custom_method(klass_ary, :[], Builtin.method(:array_aref))
-      scratch.add_custom_method(klass_ary, :[]=, Builtin.method(:array_aset))
-      scratch.add_custom_method(klass_ary, :pop, Builtin.method(:array_pop))
-
-      scratch.add_custom_method(klass_hash, :[], Builtin.method(:hash_aref))
-      scratch.add_custom_method(klass_hash, :[]=, Builtin.method(:hash_aset))
-
-      scratch.add_custom_method(klass_struct, :initialize, Builtin.method(:struct_initialize))
-      scratch.add_singleton_custom_method(klass_struct, :new, Builtin.method(:struct_s_new))
-
-      scratch.add_custom_method(klass_obj, :require, Builtin.method(:kernel_require))
-      scratch.add_custom_method(klass_obj, :require_relative, Builtin.method(:kernel_require_relative))
-      scratch.add_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))
+      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, :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))
+      scratch.set_singleton_custom_method(klass_obj, :"attr_reader", Builtin.method(:module_attr_reader))
+      scratch.set_singleton_custom_method(klass_obj, :"attr_writer", Builtin.method(:module_attr_writer))
+      scratch.set_custom_method(klass_obj, :p, Builtin.method(:kernel_p))
+      scratch.set_custom_method(klass_obj, :is_a?, Builtin.method(:object_is_a?))
+      scratch.set_custom_method(klass_obj, :respond_to?, Builtin.method(:object_respond_to?))
+      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))
+      scratch.set_custom_method(klass_module, :module_function, Builtin.method(:module_module_function))
+
+      scratch.set_custom_method(klass_proc, :[], Builtin.method(:proc_call))
+      scratch.set_custom_method(klass_proc, :call, Builtin.method(:proc_call))
+
+      scratch.set_custom_method(klass_ary, :[], Builtin.method(:array_aref))
+      scratch.set_custom_method(klass_ary, :[]=, Builtin.method(:array_aset))
+      scratch.set_custom_method(klass_ary, :pop, Builtin.method(:array_pop))
+
+      scratch.set_custom_method(klass_hash, :[], Builtin.method(:hash_aref))
+      scratch.set_custom_method(klass_hash, :[]=, Builtin.method(:hash_aset))
+
+      scratch.set_custom_method(klass_struct, :initialize, Builtin.method(:struct_initialize))
+      scratch.set_singleton_custom_method(klass_struct, :new, Builtin.method(:struct_s_new))
+
+      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/cli.rb

@@ -1,38 +1,62 @@
 require "optparse"
 
 module TypeProf
-  class CLI
-    def initialize(argv)
+  module CLI
+    module_function
+
+    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,
-      }
+      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| 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)]
+      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 ||= ConfigData::DEFAULT_DIR_FILTER
+        dir_filter << [:exclude, File.expand_path(dir)]
+      end
 
-      opt.on("-o OUTFILE") {|v| @output = v }
-      opt.on("-q", "--quiet") {|v| @verbose = 0 }
-      opt.on("-v", "--verbose") {|v| @verbose = 2 }
       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
@@ -40,71 +64,38 @@ module TypeProf
 
       opt.parse!(argv)
 
-      @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, :files
-    attr_accessor :output
-
-    def run
-      scratch = Scratch.new
-      Builtin.setup_initial_global_env(scratch)
-
-      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|
-        RubySignatureImporter.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