typeprof 0.10.0 → 0.14.1

data/lib/typeprof/block.rb

@@ -27,7 +27,7 @@ module TypeProf
       self
     end
 
-    def do_call(aargs, caller_ep, caller_env, scratch, replace_recv_ty:, &ctn)
+    def do_call(aargs, caller_ep, caller_env, scratch, replace_recv_ty:, replace_cref:, &ctn)
       blk_env = scratch.return_envs[@outer_ep]
       if replace_recv_ty
         replace_recv_ty = scratch.globalize_type(replace_recv_ty, caller_env, caller_ep)
@@ -46,7 +46,8 @@ module TypeProf
         return
       end
 
-      nctx = Context.new(@iseq, @outer_ep.ctx.cref, nil)
+      cref = replace_cref || @outer_ep.ctx.cref
+      nctx = Context.new(@iseq, cref, nil)
       callee_ep = ExecutionPoint.new(nctx, 0, @outer_ep)
       nenv = Env.new(blk_env.static_env, locals, [], nil)
       alloc_site = AllocationSite.new(callee_ep)
@@ -87,7 +88,7 @@ module TypeProf
       TypedBlock.new(msig, ret_ty)
     end
 
-    def do_call(aargs, caller_ep, caller_env, scratch, replace_recv_ty:, &ctn)
+    def do_call(aargs, caller_ep, caller_env, scratch, replace_recv_ty:, replace_cref:, &ctn)
       aargs = scratch.globalize_type(aargs, caller_env, caller_ep)
       subst = aargs.consistent_with_method_signature?(@msig)
       unless subst
@@ -119,7 +120,7 @@ module TypeProf
       self
     end
 
-    def do_call(aargs, caller_ep, caller_env, scratch, replace_recv_ty:, &ctn)
+    def do_call(aargs, caller_ep, caller_env, scratch, replace_recv_ty:, replace_cref:, &ctn)
       if aargs.lead_tys.size >= 1
         recv = aargs.lead_tys[0]
         recv = Type.any if recv == Type.bot
@@ -157,7 +158,7 @@ module TypeProf
       self
     end
 
-    def do_call(aargs, caller_ep, caller_env, scratch, replace_recv_ty:, &ctn)
+    def do_call(aargs, caller_ep, caller_env, scratch, replace_recv_ty:, replace_cref:, &ctn)
       aargs = scratch.globalize_type(aargs, caller_env, caller_ep)
 
       dummy_ctx = TypedContext.new(@caller_ep, @mid)
@@ -165,7 +166,7 @@ module TypeProf
       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|
+      @blk.call(aargs, caller_ep, caller_env, scratch, replace_recv_ty: replace_recv_ty, replace_cref: replace_cref) do |ret_ty, ep, env|
         scratch.add_return_value!(dummy_ctx, ret_ty)
         ctn[ret_ty, ep, env]
       end

data/lib/typeprof/builtin.rb

@@ -158,7 +158,43 @@ module TypeProf
       naargs = ActualArguments.new([recv], nil, {}, Type.nil)
       nrecv = recv
       nrecv = nrecv.base_type if nrecv.is_a?(Type::ContainerType)
-      scratch.do_invoke_block(aargs.blk_ty, naargs, ep, env, replace_recv_ty: nrecv) do |_ret_ty, ep|
+      scratch.do_invoke_block(aargs.blk_ty, naargs, ep, env, replace_recv_ty: nrecv) do |ret_ty, ep|
+        ctn[ret_ty, ep, env]
+      end
+    end
+
+    def module_eqq(recv, mid, aargs, ep, env, scratch, &ctn)
+      if aargs.lead_tys.size == 1
+        aargs.lead_tys[0].each_child do |aarg|
+          aarg = aarg.base_type if aarg.is_a?(Type::Symbol) # XXX
+          if aarg.is_a?(Type::Instance)
+            if aarg.klass == recv # XXX: inheritance
+              true_val = Type::Instance.new(Type::Builtin[:true])
+              ctn[true_val, ep, env]
+            else
+              false_val = Type::Instance.new(Type::Builtin[:false])
+              ctn[false_val, ep, env]
+            end
+          else
+            ctn[Type.bool, ep, env]
+          end
+        end
+      else
+        ctn[Type.bool, ep, env]
+      end
+    end
+
+    def object_module_eval(recv, mid, aargs, ep, env, scratch, &ctn)
+      if aargs.lead_tys.size >= 1
+        scratch.warn(ep, "class_eval with arguments is ignored")
+        ctn[Type.any, ep, env]
+        return
+      end
+      naargs = ActualArguments.new([recv], nil, {}, Type.nil)
+      nrecv = recv
+      nrecv = nrecv.base_type if nrecv.is_a?(Type::ContainerType)
+      ncref = ep.ctx.cref.extend(nrecv, true)
+      scratch.do_invoke_block(aargs.blk_ty, naargs, ep, env, replace_recv_ty: nrecv, replace_cref: ncref) do |_ret_ty, ep|
         ctn[recv, ep, env]
       end
     end
@@ -176,7 +212,7 @@ module TypeProf
       end
 
       elem_ty = Type.bot
-      enum_for_blk = CustomBlock.new(ep, mid) do |aargs, caller_ep, caller_env, scratch, replace_recv_ty:, &blk_ctn|
+      enum_for_blk = CustomBlock.new(ep, mid) do |aargs, caller_ep, caller_env, scratch, replace_recv_ty:, replace_cref:, &blk_ctn|
         if aargs.lead_tys.size >= 1
           elem_ty = elem_ty.union(aargs.lead_tys[0])
         else
@@ -235,9 +271,12 @@ module TypeProf
         return ctn[Type.any, ep, env]
       end
 
+      # support multiple arguments: include M1, M2
       arg = aargs.lead_tys[0]
       arg.each_child do |arg|
         if arg.is_a?(Type::Class)
+          aargs = ActualArguments.new([recv], nil, {}, Type.nil)
+          scratch.do_send(arg, :included, aargs, ep, env) {|_ret_ty, _ep| }
           scratch.mix_module(:after, recv, arg, nil, ep.ctx.cref.singleton, ep)
         end
       end
@@ -259,6 +298,8 @@ module TypeProf
       arg = aargs.lead_tys[0]
       arg.each_child do |arg|
         if arg.is_a?(Type::Class)
+          aargs = ActualArguments.new([recv], nil, {}, Type.nil)
+          scratch.do_send(arg, :extended, aargs, ep, env) {|_ret_ty, _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
@@ -557,8 +598,6 @@ module TypeProf
     end
 
     def struct_s_new(recv, mid, aargs, ep, env, scratch, &ctn)
-      # TODO: keyword_init
-
       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])
@@ -806,9 +845,12 @@ module TypeProf
       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))
-      scratch.set_custom_method(klass_module, :"attr_writer", Builtin.method(:module_attr_writer))
+      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))
+      scratch.set_custom_method(klass_module, :attr_writer, Builtin.method(:module_attr_writer))
+      scratch.set_custom_method(klass_module, :class_eval, Builtin.method(:object_module_eval))
+      scratch.set_custom_method(klass_module, :module_eval, Builtin.method(:object_module_eval))
+      scratch.set_custom_method(klass_module, :===, Builtin.method(:module_eqq))
 
       scratch.set_custom_method(klass_proc, :[], Builtin.method(:proc_call))
       scratch.set_custom_method(klass_proc, :call, Builtin.method(:proc_call))

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,6 +48,8 @@ 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 }
@@ -87,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,
@@ -25,10 +26,13 @@ module TypeProf
     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,
@@ -76,9 +80,19 @@ module TypeProf
       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(Type.bot, Type.nil, false, true), [], [], Utils::HashWrapper.new({}))
+    rbs_files = []
+    rbs_codes = []
+    Config.rbs_files.each do |rbs|
+      if rbs.is_a?(Array) # [String name, String content]
+        rbs_codes << rbs
+      else
+        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
 
     Config.rb_files.each do |rb|
       if rb.is_a?(Array) # [String name, String content]
@@ -86,17 +100,7 @@ module TypeProf
       else
         iseq = ISeq.compile(rb)
       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 |rbs|
-      if rbs.is_a?(Array) # [String name, String content]
-        Import.import_rbs_code(scratch, *rbs)
-      else
-        Import.import_rbs_file(scratch, rbs)
-      end
+      scratch.add_entrypoint(iseq)
     end
 
     result = scratch.type_profile

data/lib/typeprof/container-type.rb

@@ -45,6 +45,12 @@ module TypeProf
           Type::Cell.new(Type::Cell::Elements.new([Type.bot] * klass.type_params.size), base_type)
         end
       end
+
+      def include_untyped?(scratch)
+        return true if @base_type.include_untyped?(scratch)
+        return true if @elems.include_untyped?(scratch)
+        false
+      end
     end
 
     # The most basic container type for default type parameter class
@@ -196,6 +202,10 @@ module TypeProf
           end
           Elements.new(elems)
         end
+
+        def include_untyped?(scratch)
+          return @elems.any? {|ty| ty.include_untyped?(scratch) }
+        end
       end
     end
 
@@ -531,6 +541,12 @@ module TypeProf
             return rest_ary_ty, following_tys
           end
         end
+
+        def include_untyped?(scratch)
+          return true if @lead_tys.any? {|ty| ty.include_untyped?(scratch) }
+          return true if @rest_ty.include_untyped?(scratch)
+          false
+        end
       end
     end
 
@@ -790,6 +806,14 @@ module TypeProf
           end
           kw_tys
         end
+
+        def include_untyped?(scratch)
+          @map_tys.each do |key, val|
+            return true if key.include_untyped?(scratch)
+            return true if val.include_untyped?(scratch)
+          end
+          false
+        end
       end
     end
 

data/lib/typeprof/export.rb

@@ -26,6 +26,10 @@ module TypeProf
     end
 
     def show_message(terminated, output)
+      if Config.options[:show_typeprof_version]
+        output.puts "# TypeProf #{ VERSION }"
+        output.puts
+      end
       if terminated
         output.puts "# CAUTION: Type profiling was terminated prematurely because of the limitation"
         output.puts
@@ -94,6 +98,10 @@ module TypeProf
       if class_def.klass_obj.superclass != :__root__ && class_def.klass_obj.superclass
         omit = class_def.klass_obj.superclass == Type::Builtin[:obj] || class_def.klass_obj == Type::Builtin[:obj]
         superclass = omit ? nil : @scratch.get_class_name(class_def.klass_obj.superclass)
+        type_args = class_def.klass_obj.superclass_type_args
+        if type_args && !type_args.empty?
+          superclass += "[#{ type_args.map {|ty| ty.screen_name(@scratch) }.join(", ") }]"
+        end
       end
 
       @scratch.namespace = class_def.name
@@ -129,18 +137,17 @@ module TypeProf
             ctxs = @iseq_method_to_ctxs[mdef]
             next unless ctxs
 
-            ctxs.each do |ctx|
-              next if mid != ctx.mid
-              next if Config.check_dir_filter(ctx.iseq.absolute_path) == :exclude
+            ctx = ctxs.find {|ctx| ctx.mid == mid } || ctxs.first
 
-              method_name = ctx.mid
-              method_name = "self.#{ method_name }" if singleton
+            next if Config.check_dir_filter(ctx.iseq.absolute_path) == :exclude
 
-              key = [:iseq, method_name]
-              visibilities[key] ||= mdef.pub_meth
-              source_locations[key] ||= ctx.iseq.source_location(0)
-              (methods[key] ||= []) << @scratch.show_method_signature(ctx)
-            end
+            method_name = mid
+            method_name = "self.#{ method_name }" if singleton
+
+            key = [:iseq, method_name]
+            visibilities[key] ||= mdef.pub_meth
+            source_locations[key] ||= ctx.iseq.source_location(0)
+            (methods[key] ||= []) << @scratch.show_method_signature(ctx)
           when AliasMethodDef
             alias_name, orig_name = mid, mdef.orig_mid
             if singleton
@@ -169,7 +176,7 @@ module TypeProf
             else
               entry = ivars[[singleton, mdef.ivar]]
               ty = entry ? entry.type : Type.any
-              methods[key] = [mdef.kind, ty.screen_name(@scratch)]
+              methods[key] = [mdef.kind, ty.screen_name(@scratch), ty.include_untyped?(@scratch)]
             end
           when TypedMethodDef
             if mdef.rbs_source
@@ -336,14 +343,22 @@ module TypeProf
         type, (method_name, hidden) = key
         case type
         when :attr
-          kind, ty = *arg
-          lines << (indent + "  attr_#{ kind } #{ method_name }#{ hidden ? "()" : "" }: #{ ty }")
+          kind, ty, untyped = *arg
+          exclude = Config.options[:exclude_untyped] && untyped ? "#" : " " # XXX
+          lines << (indent + "#{ exclude } attr_#{ kind } #{ method_name }#{ hidden ? "()" : "" }: #{ ty }")
         when :rbs
           sigs = arg.sort.join("\n" + indent + "#" + " " * (method_name.size + 5) + "| ")
           lines << (indent + "# def #{ method_name }: #{ sigs }")
         when :iseq
-          sigs = arg.sort.join("\n" + indent + " " * (method_name.size + 6) + "| ")
-          lines << (indent + "  def #{ method_name }: #{ sigs }")
+          sigs = []
+          untyped = false
+          arg.each do |sig, untyped0|
+            sigs << sig
+            untyped ||= untyped0
+          end
+          sigs = sigs.sort.join("\n" + indent + " " * (method_name.size + 6) + "| ")
+          exclude = Config.options[:exclude_untyped] && untyped ? "#" : " " # XXX
+          lines << (indent + "#{ exclude } def #{ method_name }: #{ sigs }")
         when :alias
           orig_name = arg
           lines << (indent + "  alias #{ method_name } #{ orig_name }")

data/lib/typeprof/import.rb

@@ -3,6 +3,10 @@ require "rbs"
 module TypeProf
   class RBSReader
     def initialize
+      @repo = RBS::Repository.new
+      Config.gem_repo_dirs.each do |dir|
+        @repo.add(Pathname(dir))
+      end
       @env, @builtin_env_json = RBSReader.get_builtin_env
     end
 
@@ -11,7 +15,7 @@ module TypeProf
       unless @builtin_env
         @builtin_env = RBS::Environment.new
 
-        loader = RBS::EnvironmentLoader.new
+        loader = RBS::EnvironmentLoader.new(repository: @repo)
         new_decls = loader.load(env: @builtin_env).map {|decl,| decl }
         @builtin_env_json = load_rbs(@builtin_env, new_decls)
       end
@@ -24,22 +28,30 @@ module TypeProf
     end
 
     def load_library(lib)
-      loader = RBS::EnvironmentLoader.new(core_root: nil)
+      loader = RBS::EnvironmentLoader.new(core_root: nil, repository: @repo)
       loader.add(library: lib)
 
       case lib
+      when 'bigdecimal-math'
+        loader.add(library: 'bigdecimal')
       when "yaml"
         loader.add(library: "pstore")
         loader.add(library: "dbm")
+      when "logger"
+        loader.add(library: "monitor")
+      when "csv"
+        loader.add(library: "forwardable")
+      when "prime"
+        loader.add(library: "singleton")
       end
 
       new_decls = loader.load(env: @env).map {|decl,| decl }
       RBSReader.load_rbs(@env, new_decls)
     end
 
-    def load_path(path)
-      loader = RBS::EnvironmentLoader.new(core_root: nil)
-      loader.add(path: path)
+    def load_paths(paths)
+      loader = RBS::EnvironmentLoader.new(core_root: nil, repository: @repo)
+      paths.each {|path| loader.add(path: path) }
       new_decls = loader.load(env: @env).map {|decl,| decl }
       RBSReader.load_rbs(@env, new_decls)
     end
@@ -69,6 +81,7 @@ module TypeProf
   class RBS2JSON
     def initialize(all_env, cur_env)
       @all_env, @cur_env = all_env, cur_env
+      @alias_resolution_stack = {}
     end
 
     def dump_json
@@ -176,11 +189,15 @@ module TypeProf
             when RBS::AST::Members::Include
               name = member.name
               if name.kind == :class
+                # including a module
                 mod = conv_type_name(name)
                 type_args = member.args.map {|type| conv_type(type) }
                 modules[:include] << [mod, type_args]
               else
-                # including an interface is not supported yet
+                # including an interface
+                mod = conv_type_name(name)
+                type_args = member.args.map {|type| conv_type(type) }
+                modules[:include] << [mod, type_args]
               end
 
             when RBS::AST::Members::Extend
@@ -424,8 +441,17 @@ module TypeProf
           raise NotImplementedError
         end
       when RBS::Types::Alias
-        alias_decl = @all_env.alias_decls[ty.name]
-        alias_decl ? conv_type(alias_decl.decl.type) : [:any]
+        if @alias_resolution_stack[ty.name]
+          [:any]
+        else
+          begin
+            @alias_resolution_stack[ty.name] = true
+            alias_decl = @all_env.alias_decls[ty.name]
+            alias_decl ? conv_type(alias_decl.decl.type) : [:any]
+          ensure
+            @alias_resolution_stack.delete(ty.name)
+          end
+        end
       when RBS::Types::Union
         [:union, ty.types.map {|ty2| conv_type(ty2) }.compact]
       when RBS::Types::Optional
@@ -472,9 +498,9 @@ module TypeProf
       Import.new(scratch, json).import
     end
 
-    def self.import_rbs_file(scratch, rbs_path)
-      rbs_path = Pathname(rbs_path) unless rbs_path.is_a?(Pathname)
-      Import.new(scratch, scratch.rbs_reader.load_path(rbs_path)).import(true)
+    def self.import_rbs_files(scratch, rbs_paths)
+      rbs_paths = rbs_paths.map {|rbs_path| Pathname(rbs_path) }
+      Import.new(scratch, scratch.rbs_reader.load_paths(rbs_paths)).import(true)
     end
 
     def self.import_rbs_code(scratch, rbs_name, rbs_code)