typeprof 0.9.1 → 0.13.0

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
@@ -116,13 +129,13 @@ module TypeProf
         end
 
         type_params = nil
-        included_modules = []
-        extended_modules = []
+        modules = { include: [], extend: [], prepend: [] }
         methods = {}
         attr_methods = {}
         ivars = {}
         cvars = {}
         rbs_sources = {}
+        visibility = true
 
         decls.each do |decl|
           decl = decl.decl
@@ -143,7 +156,7 @@ module TypeProf
                 end
               end
 
-              method_def = conv_method_def(method_types)
+              method_def = conv_method_def(method_types, visibility)
               rbs_source = [(member.kind == :singleton ? "self." : "") + member.name.to_s, member.types.map {|type| type.location.source }]
               if member.instance?
                 methods[[false, name]] = method_def
@@ -155,13 +168,13 @@ module TypeProf
               end
             when RBS::AST::Members::AttrReader
               ty = conv_type(member.type)
-              attr_methods[[false, member.name]] = attr_method_def(:reader, member.name, ty)
+              attr_methods[[false, member.name]] = attr_method_def(:reader, member.name, ty, visibility)
             when RBS::AST::Members::AttrWriter
               ty = conv_type(member.type)
-              attr_methods[[false, member.name]] = attr_method_def(:writer, member.name, ty)
+              attr_methods[[false, member.name]] = attr_method_def(:writer, member.name, ty, visibility)
             when RBS::AST::Members::AttrAccessor
               ty = conv_type(member.type)
-              attr_methods[[false, member.name]] = attr_method_def(:accessor, member.name, ty)
+              attr_methods[[false, member.name]] = attr_method_def(:accessor, member.name, ty, visibility)
             when RBS::AST::Members::Alias
               # XXX: an alias to attr methods?
               if member.instance?
@@ -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) }
-                included_modules << [mod, type_args]
+                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
@@ -188,7 +205,17 @@ module TypeProf
               if name.kind == :class
                 mod = conv_type_name(name)
                 type_args = member.args.map {|type| conv_type(type) }
-                extended_modules << [mod, type_args]
+                modules[:extend] << [mod, type_args]
+              else
+                # extending a module with an interface is not supported yet
+              end
+
+            when RBS::AST::Members::Prepend
+              name = member.name
+              if name.kind == :class
+                mod = conv_type_name(name)
+                type_args = member.args.map {|type| conv_type(type) }
+                modules[:prepend] << [mod, type_args]
               else
                 # extending a module with an interface is not supported yet
               end
@@ -198,7 +225,10 @@ module TypeProf
             when RBS::AST::Members::ClassVariable
               cvars[member.name] = conv_type(member.type)
 
-            when RBS::AST::Members::Public, RBS::AST::Members::Private # XXX
+            when RBS::AST::Members::Public
+              visibility = true
+            when RBS::AST::Members::Private
+              visibility = false
 
             # The following declarations are ignoreable because they are handled in other level
             when RBS::AST::Declarations::Constant
@@ -216,8 +246,7 @@ module TypeProf
           type_params: type_params,
           superclass: superclass,
           members: {
-            included_modules: included_modules,
-            extended_modules: extended_modules,
+            modules: modules,
             methods: methods,
             attr_methods: attr_methods,
             ivars: ivars,
@@ -297,10 +326,14 @@ module TypeProf
       return RBS::BuiltinNames::Object.name, []
     end
 
-    def conv_method_def(rbs_method_types)
-      rbs_method_types.map do |method_type|
+    def conv_method_def(rbs_method_types, visibility)
+      sig_rets = rbs_method_types.map do |method_type|
         conv_func(method_type.type_params, method_type.type, method_type.block)
       end
+      {
+        sig_rets: sig_rets,
+        visibility: visibility,
+      }
     end
 
     def conv_func(type_params, func, block)
@@ -330,11 +363,12 @@ module TypeProf
       }
     end
 
-    def attr_method_def(kind, name, ty)
+    def attr_method_def(kind, name, ty, visibility)
       {
         kind: kind,
         ivar: name,
         ty: ty,
+        visibility: visibility,
       }
     end
 
@@ -407,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
@@ -455,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)
@@ -502,22 +545,25 @@ module TypeProf
 
       classes.each do |klass, superclass_type_args, members|
         @scratch.add_superclass_type_args!(klass, superclass_type_args&.map {|ty| conv_type(ty) })
-        included_modules = members[:included_modules]
-        extended_modules = members[:extended_modules]
+        modules = members[:modules]
         methods = members[:methods]
         attr_methods = members[:attr_methods]
         ivars = members[:ivars]
         cvars = members[:cvars]
         rbs_sources = members[:rbs_sources]
 
-        included_modules.each do |mod, type_args|
-          type_args = type_args&.map {|ty| conv_type(ty) }
-          @scratch.include_module(klass, path_to_klass(mod), type_args, false, nil)
-        end
-
-        extended_modules.each do |mod, type_args|
-          type_args = type_args&.map {|ty| conv_type(ty) }
-          @scratch.include_module(klass, path_to_klass(mod), type_args, true, nil)
+        modules.each do |kind, mods|
+          mods.each do |mod, type_args|
+            type_args = type_args&.map {|ty| conv_type(ty) }
+            case kind
+            when :include
+              @scratch.mix_module(:after, klass, path_to_klass(mod), type_args, false, nil)
+            when :extend
+              @scratch.mix_module(:after, klass, path_to_klass(mod), type_args, true, nil)
+            when :prepend
+              @scratch.mix_module(:before, klass, path_to_klass(mod), type_args, false, nil)
+            end
+          end
         end
 
         methods.each do |(singleton, method_name), mdef|
@@ -530,7 +576,7 @@ module TypeProf
           kind = mdef[:kind]
           ivar = mdef[:ivar]
           ty = conv_type(mdef[:ty]).remove_type_vars
-          @scratch.add_attr_method(klass, nil, ivar, :"@#{ ivar }", kind)
+          @scratch.add_attr_method(klass, ivar, :"@#{ ivar }", kind, mdef[:visibility], nil)
           @scratch.add_ivar_write!(Type::Instance.new(klass), :"@#{ ivar }", ty, nil)
         end
 
@@ -560,11 +606,11 @@ module TypeProf
     end
 
     def conv_method_def(method_name, mdef, rbs_source)
-      sig_rets = mdef.flat_map do |sig_ret|
+      sig_rets = mdef[:sig_rets].flat_map do |sig_ret|
         conv_func(sig_ret)
       end
 
-      TypedMethodDef.new(sig_rets, rbs_source)
+      TypedMethodDef.new(sig_rets, rbs_source, mdef[:visibility])
     end
 
     def conv_func(sig_ret)
@@ -664,7 +710,9 @@ module TypeProf
       klass = Type::Builtin[:obj]
       path.each do |name|
         klass = @scratch.get_constant(klass, name)
-        raise path.inspect if klass == Type.any
+        if klass == Type.any
+          raise TypeProfError.new("A constant `#{ path.join("::") }' is used but not defined in RBS")
+        end
       end
       klass
     end

data/lib/typeprof/iseq.rb

@@ -207,7 +207,7 @@ module TypeProf
       end
 
       # find a pattern: getlocal, ..., send (is_a?, respond_to?), branch
-      send_branch_list = []
+      getlocal_send_branch_list = []
       (@insns.size - 1).times do |i|
         insn, operands = @insns[i]
         if insn == :getlocal && operands[1] == 0
@@ -216,7 +216,7 @@ module TypeProf
           while @insns[j]
             sp = check_send_branch(sp, j)
             if sp == :match
-              send_branch_list << [i, j]
+              getlocal_send_branch_list << [i, j]
               break
             end
             break if !sp
@@ -224,13 +224,32 @@ module TypeProf
           end
         end
       end
-      send_branch_list.each do |i, j|
+      getlocal_send_branch_list.each do |i, j|
         next if (i + 1 .. j + 1).any? {|i| branch_targets[i] }
         _insn, getlocal_operands = @insns[i]
         _insn, send_operands = @insns[j]
         _insn, branch_operands = @insns[j + 1]
         @insns[j] = [:nop]
-        @insns[j + 1] = [:send_branch, [getlocal_operands, send_operands, branch_operands]]
+        @insns[j + 1] = [:getlocal_send_branch, [getlocal_operands, send_operands, branch_operands]]
+      end
+
+      # find a pattern: send (block_given?), branch
+      send_branch_list = []
+      (@insns.size - 1).times do |i|
+        insn, _operands = @insns[i]
+        if insn == :send
+          insn, _operands = @insns[i + 1]
+          if insn == :branch
+            send_branch_list << i
+          end
+        end
+      end
+      send_branch_list.each do |i|
+        next if branch_targets[i + 1]
+        _insn, send_operands = @insns[i]
+        _insn, branch_operands = @insns[i + 1]
+        @insns[i] = [:nop]
+        @insns[i + 1] = [:send_branch, [send_operands, branch_operands]]
       end
 
       # find a pattern: getlocal, dup, branch

data/lib/typeprof/method.rb

@@ -1,5 +1,7 @@
 module TypeProf
   class MethodDef
+    attr_accessor :pub_meth
+
     include Utils::StructuralEquality
   end
 
@@ -12,8 +14,6 @@ module TypeProf
       @pub_meth = pub_meth
     end
 
-    attr_accessor :pub_meth
-
     def do_send(recv, mid, aargs, caller_ep, caller_env, scratch, &ctn)
       recv = recv.base_type while recv.respond_to?(:base_type)
       recv = scratch.globalize_type(recv, caller_env, caller_ep)
@@ -153,14 +153,34 @@ module TypeProf
     end
   end
 
+  class AliasMethodDef < MethodDef
+    def initialize(orig_mid, mdef, def_ep)
+      @orig_mid = orig_mid
+      @mdef = mdef
+      @pub_meth = mdef.pub_meth
+      @def_ep = def_ep
+    end
+
+    attr_reader :orig_mid, :mdef, :def_ep
+
+    def do_send(recv, _mid, aargs, caller_ep, caller_env, scratch, &ctn)
+      @mdef.do_send(recv, @orig_mid, aargs, caller_ep, caller_env, scratch, &ctn)
+    end
+
+    def do_check_send(msig, recv, mid, ep, scratch)
+      @mdef.do_check_send(msig, recv, mid, ep, scratch)
+    end
+  end
+
   class AttrMethodDef < MethodDef
-    def initialize(ivar, kind, absolute_path)
+    def initialize(ivar, kind, pub_meth, def_ep)
       @ivar = ivar
       @kind = kind # :reader | :writer
-      @absolute_path = absolute_path
+      @pub_meth = pub_meth
+      @def_ep = def_ep
     end
 
-    attr_reader :ivar, :kind, :absolute_path
+    attr_reader :ivar, :kind, :def_ep
 
     def do_send(recv, mid, aargs, caller_ep, caller_env, scratch, &ctn)
       case @kind
@@ -185,9 +205,10 @@ module TypeProf
   end
 
   class TypedMethodDef < MethodDef
-    def initialize(sig_rets, rbs_source) # sig_rets: Array<[MethodSignature, (return)Type]>
+    def initialize(sig_rets, rbs_source, pub_meth) # sig_rets: Array<[MethodSignature, (return)Type]>
       @sig_rets = sig_rets
       @rbs_source = rbs_source
+      @pub_meth = pub_meth
     end
 
     attr_reader :rbs_source
@@ -286,8 +307,9 @@ module TypeProf
   end
 
   class CustomMethodDef < MethodDef
-    def initialize(impl)
+    def initialize(impl, pub_meth)
       @impl = impl
+      @pub_meth = pub_meth
     end
 
     def do_send(recv, mid, aargs, caller_ep, caller_env, scratch, &ctn)

data/lib/typeprof/type.rb

@@ -162,6 +162,10 @@ module TypeProf
       substitute(DummySubstitution, Config.options[:type_depth_limit])
     end
 
+    def include_untyped?(_scratch)
+      false
+    end
+
     class Any < Type
       def initialize
       end
@@ -185,6 +189,10 @@ module TypeProf
       def substitute(_subst, _depth)
         self
       end
+
+      def include_untyped?(_scratch)
+        true
+      end
     end
 
     class Void < Any
@@ -379,6 +387,17 @@ module TypeProf
         end
         ty
       end
+
+      def include_untyped?(scratch)
+        @types.each do |ty|
+          return true if ty.include_untyped?(scratch)
+        end
+        @elems&.each do |(container_kind, base_type), elems|
+          return true if base_type.include_untyped?(scratch)
+          return true if elems.include_untyped?(scratch)
+        end
+        false
+      end
     end
 
     def self.any
@@ -583,6 +602,10 @@ module TypeProf
       def screen_name(scratch)
         scratch.show_proc_signature([self])
       end
+
+      def include_untyped?(scratch)
+        false # XXX: need to check the block signatures recursively
+      end
     end
 
     class Symbol < Type
@@ -781,31 +804,56 @@ module TypeProf
   class Signature
     include Utils::StructuralEquality
 
-    def screen_name(scratch)
-      str = @lead_tys.map {|ty| ty.screen_name(scratch) }
+    def screen_name(iseq, scratch)
+      fargs = @lead_tys.map {|ty| ty.screen_name(scratch) }
+      farg_names = []
+      farg_names += iseq.locals[0, @lead_tys.size] if iseq
       if @opt_tys
-        str += @opt_tys.map {|ty| "?" + ty.screen_name(scratch) }
+        fargs += @opt_tys.map {|ty| "?" + ty.screen_name(scratch) }
+        farg_names += iseq.locals[@lead_tys.size, @opt_tys.size] if iseq
       end
       if @rest_ty
-        str << ("*" + @rest_ty.screen_name(scratch))
+        fargs << ("*" + @rest_ty.screen_name(scratch))
+        if iseq
+          rest_index = iseq.fargs_format[:rest_start]
+          farg_names << (rest_index ? iseq.locals[rest_index] : nil)
+        end
       end
       if @post_tys
-        str += @post_tys.map {|ty| ty.screen_name(scratch) }
+        fargs += @post_tys.map {|ty| ty.screen_name(scratch) }
+        if iseq
+          post_start = iseq.fargs_format[:post_start]
+          farg_names += (post_start ? iseq.locals[post_start, @post_tys.size] : [nil] * @post_tys.size)
+        end
       end
       if @kw_tys
         @kw_tys.each do |req, sym, ty|
           opt = req ? "" : "?"
-          str << "#{ opt }#{ sym }: #{ ty.screen_name(scratch) }"
+          fargs << "#{ opt }#{ sym }: #{ ty.screen_name(scratch) }"
         end
       end
       if @kw_rest_ty
-        str << ("**" + @kw_rest_ty.screen_name(scratch))
+        all_val_ty = Type.bot
+        @kw_rest_ty.each_child_global do |ty|
+          if ty == Type.any
+            val_ty = ty
+          else
+            # ty is a Type::Hash
+            _key_ty, val_ty = ty.elems.squash
+          end
+          all_val_ty = all_val_ty.union(val_ty)
+        end
+        fargs << ("**" + all_val_ty.screen_name(scratch))
+      end
+      if Config.options[:show_parameter_names]
+        farg_names = farg_names.map {|name| name == :type ? :type_ : name } # XXX: workaround of RBS parser bug
+        fargs = fargs.zip(farg_names).map {|farg, name| name ? "#{ farg } #{ name }" : farg }
       end
-      str = str.empty? ? "" : "(#{ str.join(", ") })"
+      fargs = fargs.empty? ? "" : "(#{ fargs.join(", ") })"
 
       # Dirty Hack: Stop the iteration at most once!
       # I'll remove this hack if RBS removes the limitation of nesting blocks
-      return str if caller_locations.any? {|frame| frame.label == "show_block_signature" }
+      return fargs if caller_locations.any? {|frame| frame.label == "show_block_signature" }
 
       optional = false
       blks = []
@@ -818,12 +866,12 @@ module TypeProf
         end
       end
       if blks != []
-        str << " " if str != ""
-        str << "?" if optional
-        str << scratch.show_block_signature(blks)
+        fargs << " " if fargs != ""
+        fargs << "?" if optional
+        fargs << scratch.show_block_signature(blks)
       end
 
-      str
+      fargs
     end
   end
 
@@ -838,9 +886,23 @@ module TypeProf
       @kw_tys = kw_tys
       kw_tys.each {|a| raise if a.size != 3 } if kw_tys
       @kw_rest_ty = kw_rest_ty
+      kw_rest_ty&.each_child_global do |ty|
+        raise ty.inspect if ty != Type.any && !ty.is_a?(Type::Hash)
+      end
       @blk_ty = blk_ty
     end
 
+    def include_untyped?(scratch)
+      return true if @lead_tys.any? {|ty| ty.include_untyped?(scratch) }
+      return true if @opt_tys.any? {|ty| ty.include_untyped?(scratch) }
+      return true if @rest_ty&.include_untyped?(scratch)
+      return true if @post_tys.any? {|ty| ty.include_untyped?(scratch) }
+      return true if @kw_tys&.any? {|_, _, ty| ty.include_untyped?(scratch) }
+      return true if @kw_rest_ty&.include_untyped?(scratch)
+      return true if @blk_ty&.include_untyped?(scratch)
+      false
+    end
+
     attr_reader :lead_tys, :opt_tys, :rest_ty, :post_tys, :kw_tys, :kw_rest_ty, :blk_ty
 
     def substitute(subst, depth)