typeprof 0.9.0 → 0.12.0

data/lib/typeprof/block.rb

@@ -137,4 +137,38 @@ module TypeProf
       end
     end
   end
+
+  class CustomBlock < Block
+    def initialize(caller_ep, mid, &blk)
+      @caller_ep = caller_ep
+      @mid = mid
+      @blk = blk
+    end
+
+    def inspect
+      "#<CustomBlock>"
+    end
+
+    def consistent?(other)
+      true # XXX
+    end
+
+    def substitute(_subst, _depth)
+      self
+    end
+
+    def do_call(aargs, caller_ep, caller_env, scratch, replace_recv_ty:, &ctn)
+      aargs = scratch.globalize_type(aargs, caller_env, caller_ep)
+
+      dummy_ctx = TypedContext.new(@caller_ep, @mid)
+
+      scratch.add_block_signature!(self, aargs.to_block_signature)
+      scratch.add_block_to_ctx!(self, dummy_ctx)
+
+      @blk.call(aargs, caller_ep, caller_env, scratch, replace_recv_ty: replace_recv_ty) do |ret_ty, ep, env|
+        scratch.add_return_value!(dummy_ctx, ret_ty)
+        ctn[ret_ty, ep, env]
+      end
+    end
+  end
 end

data/lib/typeprof/builtin.rb

@@ -19,7 +19,7 @@ module TypeProf
       klass, new_mid, old_mid = aargs.lead_tys
       new_sym = get_sym("alias", new_mid, ep, scratch) or return
       old_sym = get_sym("alias", old_mid, ep, scratch) or return
-      scratch.alias_method(klass, ep.ctx.cref.singleton, new_sym, old_sym)
+      scratch.alias_method(klass, ep.ctx.cref.singleton, new_sym, old_sym, ep)
       ctn[Type.nil, ep, env]
     end
 
@@ -163,6 +163,66 @@ module TypeProf
       end
     end
 
+    def object_enum_for(recv, mid, aargs, ep, env, scratch, &ctn)
+      if aargs.lead_tys.size >= 1
+        mid_ty, = aargs.lead_tys
+        naargs = ActualArguments.new(aargs.lead_tys[1..], aargs.rest_ty, aargs.kw_tys, aargs.blk_ty)
+      elsif aargs.rest_ty
+        mid_ty = aargs.rest_ty
+        naargs = aargs
+      else
+        mid_ty = Type::Symbol.new(:each, Type::Instance.new(Type::Builtin[:sym]))
+        naargs = aargs
+      end
+
+      elem_ty = Type.bot
+      enum_for_blk = CustomBlock.new(ep, mid) do |aargs, caller_ep, caller_env, scratch, replace_recv_ty:, &blk_ctn|
+        if aargs.lead_tys.size >= 1
+          elem_ty = elem_ty.union(aargs.lead_tys[0])
+        else
+          elem_ty = elem_ty.union(Type.any)
+        end
+        ctn[Type::Cell.new(Type::Cell::Elements.new([elem_ty, Type.any]), Type::Instance.new(Type::Builtin[:enumerator])), ep, env]
+        blk_ctn[Type.any, caller_ep, caller_env]
+      end
+      enum_for_blk_ty = Type::Proc.new(enum_for_blk, Type::Instance.new(Type::Builtin[:proc]))
+
+      naargs = ActualArguments.new(naargs.lead_tys, naargs.rest_ty, naargs.kw_tys, enum_for_blk_ty)
+      mid_ty.each_child do |mid|
+        if mid.is_a?(Type::Symbol)
+          mid = mid.sym
+          scratch.do_send(recv, mid, naargs, ep, env) do |_ret_ty, _ep|
+            ctn[Type::Cell.new(Type::Cell::Elements.new([elem_ty, Type.any]), Type::Instance.new(Type::Builtin[:enumerator])), ep, env]
+          end
+        end
+      end
+    end
+
+    def object_privitive_method(recv, mid, aargs, ep, env, scratch, &ctn)
+      ctn[Type::Symbol.new(ep.ctx.mid, Type::Instance.new(Type::Builtin[:sym])), ep, env]
+    end
+
+    def object_block_given?(recv, mid, aargs, ep, env, scratch, &ctn)
+      procs = Type.bot
+      no_proc = false
+      env.static_env.blk_ty.each_child do |blk_ty|
+        case blk_ty
+        when Type::Proc
+          procs = procs.union(blk_ty)
+        when Type.nil
+          no_proc = true
+        else
+          ctn[Type.bool, ep, env]
+        end
+      end
+      if procs != Type.bot
+        ctn[Type::Instance.new(Type::Builtin[:true]), ep, env.replace_blk_ty(procs)]
+      end
+      if no_proc
+        ctn[Type::Instance.new(Type::Builtin[:false]), ep, env.replace_blk_ty(Type.nil)]
+      end
+    end
+
     def module_include(recv, mid, aargs, ep, env, scratch, &ctn)
       if aargs.lead_tys.size != 1
         scratch.warn(ep, "Module#include without an argument is ignored")
@@ -178,7 +238,7 @@ module TypeProf
       arg = aargs.lead_tys[0]
       arg.each_child do |arg|
         if arg.is_a?(Type::Class)
-          scratch.include_module(recv, arg, nil, false, ep)
+          scratch.mix_module(:after, recv, arg, nil, ep.ctx.cref.singleton, ep)
         end
       end
       ctn[recv, ep, env]
@@ -199,7 +259,29 @@ module TypeProf
       arg = aargs.lead_tys[0]
       arg.each_child do |arg|
         if arg.is_a?(Type::Class)
-          scratch.include_module(recv, arg, nil, true, ep)
+          # if ep.ctx.cref.singleton is true, the meta-meta level is ignored. Should we warn?
+          scratch.mix_module(:after, recv, arg, nil, true, ep)
+        end
+      end
+      ctn[recv, ep, env]
+    end
+
+    def module_prepend(recv, mid, aargs, ep, env, scratch, &ctn)
+      if aargs.lead_tys.size != 1
+        scratch.warn(ep, "Module#prepend without an argument is ignored")
+        ctn[Type.any, ep, env]
+        return
+      end
+
+      unless recv.is_a?(Type::Class)
+        # XXX: warn?
+        return ctn[Type.any, ep, env]
+      end
+
+      arg = aargs.lead_tys[0]
+      arg.each_child do |arg|
+        if arg.is_a?(Type::Class)
+          scratch.mix_module(:before, recv, arg, nil, ep.ctx.cref.singleton, ep)
         end
       end
       ctn[recv, ep, env]
@@ -268,23 +350,25 @@ module TypeProf
       end
 
       mid, = aargs.lead_tys
-      if mid.is_a?(Type::Symbol)
-        mid = mid.sym
-        aargs.blk_ty.each_child do |blk_ty|
-          if blk_ty.is_a?(Type::Proc)
-            blk = blk_ty.block_body
-            case blk
-            when ISeqBlock
-              scratch.do_define_iseq_method(ep, env, mid, blk.iseq, blk.outer_ep)
+      mid.each_child do |mid|
+        if mid.is_a?(Type::Symbol)
+          mid = mid.sym
+          aargs.blk_ty.each_child do |blk_ty|
+            if blk_ty.is_a?(Type::Proc)
+              blk = blk_ty.block_body
+              case blk
+              when ISeqBlock
+                scratch.do_define_iseq_method(ep, env, mid, blk.iseq, blk.outer_ep)
+              else
+                # XXX: what to do?
+              end
             else
               # XXX: what to do?
             end
-          else
-            # XXX: what to do?
           end
+        else
+          # XXX: what to do?
         end
-      else
-        # XXX: what to do?
       end
       ctn[Type.any, ep, env]
     end
@@ -293,7 +377,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, ep.ctx.iseq.absolute_path, sym, :"@#{ sym }", :accessor)
+        scratch.add_attr_method(cref.klass, sym, :"@#{ sym }", :accessor, env.static_env.pub_meth, ep)
       end
       ctn[Type.nil, ep, env]
     end
@@ -302,7 +386,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, ep.ctx.iseq.absolute_path, sym, :"@#{ sym }", :reader)
+        scratch.add_attr_method(cref.klass, sym, :"@#{ sym }", :reader, env.static_env.pub_meth, ep)
       end
       ctn[Type.nil, ep, env]
     end
@@ -311,7 +395,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, ep.ctx.iseq.absolute_path, sym, :"@#{ sym }", :writer)
+        scratch.add_attr_method(cref.klass, sym, :"@#{ sym }", :writer, env.static_env.pub_meth, ep)
       end
       ctn[Type.nil, ep, env]
     end
@@ -444,43 +528,55 @@ module TypeProf
         ctn[Type.any, ep, env]
         return
       end
-      scratch.add_ivar_read!(Type::Instance.new(struct_klass), :_members, ep) do |member_ary_ty, ep|
-        next if member_ary_ty == Type.bot
-        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)
+      scratch.add_ivar_read!(Type::Instance.new(struct_klass), :_keyword_init, ep) do |keyword_init, ep|
+        scratch.add_ivar_read!(Type::Instance.new(struct_klass), :_members, ep) do |member_ary_ty, ep|
+          next if member_ary_ty == Type.nil
+          if keyword_init == Type::Instance.new(Type::Builtin[:true])
+            # TODO: support kw_rest_ty
+            aargs.kw_tys.each do |key, val_ty|
+              found = false
+              member_ary_ty.elems.lead_tys.each do |sym|
+                if sym.sym == key
+                  found = true
+                  scratch.set_instance_variable(recv, sym.sym, val_ty, ep, env)
+                end
+              end
+              unless found
+                # TODO: what to do when not found?
+              end
+            end
+          else
+            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
         end
       end
       ctn[recv, ep, env]
     end
 
-    def struct_i_new(recv, mid, aargs, ep, env, scratch, &ctn)
-      # TODO: keyword_init
-
-      meths = scratch.get_method(recv, false, :initialize)
-      recv = Type::Instance.new(recv)
-      meths.flat_map do |meth|
-        meth.do_send(recv, :initialize, aargs, ep, env, scratch) do |ret_ty, ep, env|
-          ctn[recv, ep, env]
+    def struct_s_new(recv, mid, aargs, ep, env, scratch, &ctn)
+      keyword_init = false
+      if aargs.kw_tys && aargs.kw_tys[:keyword_init] # XXX: more canonical way to extract keyword...
+        if aargs.kw_tys[:keyword_init] == Type::Instance.new(Type::Builtin[:true])
+          keyword_init = true
         end
       end
-    end
-
-    def struct_s_new(recv, mid, aargs, ep, env, scratch, &ctn)
-      # TODO: keyword_init
 
       fields = aargs.lead_tys.map {|ty| get_sym("Struct.new", ty, ep, scratch) }.compact
       struct_klass = scratch.new_struct(ep)
 
-      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))
+      scratch.set_singleton_custom_method(struct_klass, :new, Builtin.method(:object_s_new))
+      scratch.set_singleton_custom_method(struct_klass, :[], Builtin.method(:object_s_new))
       fields.each do |field|
-        scratch.add_attr_method(struct_klass, ep.ctx.iseq.absolute_path, field, field, :accessor)
+        scratch.add_attr_method(struct_klass, field, field, :accessor, true, ep)
       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.add_ivar_write!(Type::Instance.new(struct_klass), :_members, fields, ep)
+      scratch.add_ivar_write!(Type::Instance.new(struct_klass), :_keyword_init, Type::Instance.new(Type::Builtin[:true]), ep) if keyword_init
       #set_singleton_custom_method(struct_klass, :members, Builtin.method(:...))
 
       ctn[struct_klass, ep, env]
@@ -654,25 +750,26 @@ module TypeProf
 
       Import.import_builtin(scratch)
 
-      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)
-      Type::Builtin[:complex]   = scratch.get_constant(klass_obj, :Complex)
-      Type::Builtin[:sym]       = scratch.get_constant(klass_obj, :Symbol)
-      Type::Builtin[:str]       = scratch.get_constant(klass_obj, :String)
-      Type::Builtin[:struct]    = scratch.get_constant(klass_obj, :Struct)
-      Type::Builtin[:ary]       = scratch.get_constant(klass_obj, :Array)
-      Type::Builtin[:hash]      = scratch.get_constant(klass_obj, :Hash)
-      Type::Builtin[:io]        = scratch.get_constant(klass_obj, :IO)
-      Type::Builtin[:proc]      = scratch.get_constant(klass_obj, :Proc)
-      Type::Builtin[:range]     = scratch.get_constant(klass_obj, :Range)
-      Type::Builtin[:regexp]    = scratch.get_constant(klass_obj, :Regexp)
-      Type::Builtin[:matchdata] = scratch.get_constant(klass_obj, :MatchData)
-      Type::Builtin[:class]     = scratch.get_constant(klass_obj, :Class)
-      Type::Builtin[:module]    = scratch.get_constant(klass_obj, :Module)
-      Type::Builtin[:exc]       = scratch.get_constant(klass_obj, :Exception)
-      Type::Builtin[:encoding]  = scratch.get_constant(klass_obj, :Encoding)
+      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)
+      Type::Builtin[:complex]    = scratch.get_constant(klass_obj, :Complex)
+      Type::Builtin[:sym]        = scratch.get_constant(klass_obj, :Symbol)
+      Type::Builtin[:str]        = scratch.get_constant(klass_obj, :String)
+      Type::Builtin[:struct]     = scratch.get_constant(klass_obj, :Struct)
+      Type::Builtin[:ary]        = scratch.get_constant(klass_obj, :Array)
+      Type::Builtin[:hash]       = scratch.get_constant(klass_obj, :Hash)
+      Type::Builtin[:io]         = scratch.get_constant(klass_obj, :IO)
+      Type::Builtin[:proc]       = scratch.get_constant(klass_obj, :Proc)
+      Type::Builtin[:range]      = scratch.get_constant(klass_obj, :Range)
+      Type::Builtin[:regexp]     = scratch.get_constant(klass_obj, :Regexp)
+      Type::Builtin[:matchdata]  = scratch.get_constant(klass_obj, :MatchData)
+      Type::Builtin[:class]      = scratch.get_constant(klass_obj, :Class)
+      Type::Builtin[:module]     = scratch.get_constant(klass_obj, :Module)
+      Type::Builtin[:exc]        = scratch.get_constant(klass_obj, :Exception)
+      Type::Builtin[:encoding]   = scratch.get_constant(klass_obj, :Encoding)
+      Type::Builtin[:enumerator] = scratch.get_constant(klass_obj, :Enumerator)
 
       klass_vmcore = Type::Builtin[:vmcore]
       klass_ary    = Type::Builtin[:ary]
@@ -687,19 +784,25 @@ module TypeProf
       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_custom_method(klass_obj, :p, Builtin.method(:kernel_p))
+      scratch.set_custom_method(klass_obj, :p, Builtin.method(:kernel_p), false)
       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_obj, :proc, Builtin.method(:lambda), false)
+      scratch.set_custom_method(klass_obj, :__method__, Builtin.method(:object_privitive_method), false)
+      scratch.set_custom_method(klass_obj, :block_given?, Builtin.method(:object_block_given?), false)
+
+      scratch.set_custom_method(klass_obj, :enum_for, Builtin.method(:object_enum_for))
+      scratch.set_custom_method(klass_obj, :to_enum, Builtin.method(:object_enum_for))
 
       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_module, :public, Builtin.method(:module_public))
-      scratch.set_custom_method(klass_module, :private, Builtin.method(:module_private))
+      scratch.set_custom_method(klass_module, :prepend, Builtin.method(:module_prepend))
+      scratch.set_custom_method(klass_module, :module_function, Builtin.method(:module_module_function), false)
+      scratch.set_custom_method(klass_module, :public, Builtin.method(:module_public), false)
+      scratch.set_custom_method(klass_module, :private, Builtin.method(:module_private), false)
       scratch.set_custom_method(klass_module, :define_method, Builtin.method(:module_define_method))
       scratch.set_custom_method(klass_module, :"attr_accessor", Builtin.method(:module_attr_accessor))
       scratch.set_custom_method(klass_module, :"attr_reader", Builtin.method(:module_attr_reader))
@@ -718,10 +821,10 @@ module TypeProf
       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))
-      scratch.set_custom_method(klass_obj, :autoload, Builtin.method(:kernel_autoload))
+      scratch.set_custom_method(klass_obj, :require, Builtin.method(:kernel_require), false)
+      scratch.set_custom_method(klass_obj, :require_relative, Builtin.method(:kernel_require_relative), false)
+      scratch.set_custom_method(klass_obj, :Array, Builtin.method(:kernel_Array), false)
+      scratch.set_custom_method(klass_obj, :autoload, Builtin.method(:kernel_autoload), false)
       scratch.set_custom_method(klass_module, :autoload, Builtin.method(:module_autoload))
 
       # remove BasicObject#method_missing

data/lib/typeprof/cli.rb

@@ -20,6 +20,7 @@ module TypeProf
       options = {}
       dir_filter = nil
       gem_rbs_features = []
+      gem_repo_dirs = []
       show_version = false
       max_sec = max_iter = nil
 
@@ -31,6 +32,7 @@ module TypeProf
       opt.on("--version", "Display typeprof version") { show_version = true }
       opt.on("-I DIR", "Add DIR to the load/require path") {|v| $LOAD_PATH << v }
       opt.on("-r FEATURE", "Require RBS of the FEATURE gem") {|v| gem_rbs_features << v }
+      opt.on("--repo DIR", "Add DIR to the RBS repository") {|v| gem_repo_dirs << v }
 
       opt.separator ""
       opt.separator "Analysis output options:"
@@ -46,8 +48,12 @@ module TypeProf
         dir_filter ||= ConfigData::DEFAULT_DIR_FILTER
         dir_filter << [:exclude, File.expand_path(dir)]
       end
+      opt.on("--exclude-untyped", "Exclude (comment out) all entries including untyped") {|v| options[:exclude_untyped] = v }
+      opt.on("--[no-]show-typeprof-version", "Display TypeProf version in a header") {|v| options[:show_typeprof_version] = v }
       opt.on("--[no-]show-errors", "Display possible errors found during the analysis") {|v| options[:show_errors] = v }
       opt.on("--[no-]show-untyped", "Display \"Foo | untyped\" instead of \"Foo\"") {|v| options[:show_untyped] = v }
+      opt.on("--[no-]show-parameter-names", "Display parameter names for methods") {|v| options[:show_parameter_names] = v }
+      opt.on("--[no-]show-source-locations", "Display definition source locations for methods") {|v| options[:show_source_locations] = v }
 
       opt.separator ""
       opt.separator "Analysis limit options:"
@@ -85,6 +91,7 @@ module TypeProf
         rbs_files: rbs_files,
         output: output,
         gem_rbs_features: gem_rbs_features,
+        gem_repo_dirs: gem_repo_dirs,
         verbose: verbose,
         dir_filter: dir_filter,
         max_sec: max_sec,

data/lib/typeprof/config.rb

@@ -6,6 +6,7 @@ module TypeProf
     :rbs_files,
     :output,
     :gem_rbs_features,
+    :gem_repo_dirs,
     :verbose,
     :dir_filter,
     :max_iter,
@@ -14,17 +15,29 @@ module TypeProf
     keyword_init: true
   )
 
+  class TypeProfError < StandardError
+    def report(output)
+      output.puts "# Analysis Error"
+      output.puts message
+    end
+  end
+
   class ConfigData
     def initialize(**opt)
       opt[:output] ||= $stdout
       opt[:gem_rbs_features] ||= []
+      opt[:gem_repo_dirs] ||= []
       opt[:dir_filter] ||= DEFAULT_DIR_FILTER
       opt[:verbose] ||= 0
       opt[:options] ||= {}
       opt[:options] = {
+        exclude_untyped: false,
+        show_typeprof_version: true,
         show_indicator: true,
         show_untyped: false,
         show_errors: false,
+        show_parameter_names: true,
+        show_source_locations: false,
         stub_execution: true,
         type_depth_limit: 5,
         stackprof: nil,
@@ -69,7 +82,7 @@ module TypeProf
 
     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, true), [], [], Utils::HashWrapper.new({}))
+    prologue_env = Env.new(StaticEnv.new(Type.bot, Type.nil, false, true), [], [], Utils::HashWrapper.new({}))
 
     Config.rb_files.each do |rb|
       if rb.is_a?(Array) # [String name, String content]
@@ -82,13 +95,19 @@ module TypeProf
       scratch.add_callsite!(ep.ctx, prologue_ep, prologue_env) {|ty, ep| }
     end
 
+    rbs_files = []
+    rbs_codes = []
     Config.rbs_files.each do |rbs|
       if rbs.is_a?(Array) # [String name, String content]
-        Import.import_rbs_code(scratch, *rbs)
+        rbs_codes << rbs
       else
-        Import.import_rbs_file(scratch, rbs)
+        rbs_files << rbs
       end
     end
+    Import.import_rbs_files(scratch, rbs_files)
+    rbs_codes.each do |name, content|
+      Import.import_rbs_code(scratch, name, content)
+    end
 
     result = scratch.type_profile
 
@@ -100,6 +119,9 @@ module TypeProf
       end
     end
 
+  rescue TypeProfError => exc
+    exc.report(Config.output)
+
   ensure
     if Config.options[:stackprof] && defined?(StackProf)
       StackProf.stop