typeprof 0.9.2 → 0.14.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

@@ -206,8 +206,76 @@ module TypeProf
         end
       end
 
-      # find a pattern: getlocal, ..., send (is_a?, respond_to?), branch
-      send_branch_list = []
+      # flow-sensitive analysis for `case var; when A; when B; when C; end`
+      # find a pattern: getlocal, (dup, putobject(true), getconstant(class name), checkmatch, branch)* for ..Ruby 3.0
+      # find a pattern: getlocal, (putobject(true), getconstant(class name), top(1), send(===), branch)* for Ruby 3.1..
+      case_branch_list = []
+      if (RUBY_VERSION.split(".") <=> %w(3 1 0)) < 0
+        (@insns.size - 1).times do |i|
+          insn0, getlocal_operands = @insns[i]
+          next unless [:getlocal, :getblockparam, :getblockparamproxy].include?(insn0) && getlocal_operands[1] == 0
+          nops = [i]
+          new_insns = []
+          j = i + 1
+          while true
+            case @insns[j]
+            when [:dup, []]
+              break unless @insns[j + 1] == [:putnil, []]
+              break unless @insns[j + 2] == [:putobject, [true]]
+              break unless @insns[j + 3][0] == :getconstant # TODO: support A::B::C
+              break unless @insns[j + 4] == [:checkmatch, [2]]
+              break unless @insns[j + 5][0] == :branch
+              target_pc = @insns[j + 5][1][1]
+              break unless @insns[target_pc] == [:pop, []]
+              nops << j << (j + 4) << target_pc
+              new_insns << [j + 5, [:getlocal_checkmatch_branch, [getlocal_operands, @insns[j + 5][1]]]]
+              j += 6
+            when [:pop, []]
+              nops << j
+              case_branch_list << [nops, new_insns]
+              break
+            else
+              break
+            end
+          end
+        end
+      else
+        (@insns.size - 1).times do |i|
+          insn0, getlocal_operands = @insns[i]
+          next unless [:getlocal, :getblockparam, :getblockparamproxy].include?(insn0) && getlocal_operands[1] == 0
+          nops = []
+          new_insns = []
+          j = i + 1
+          while true
+            case @insns[j]
+            when [:putnil, []]
+              break unless @insns[j + 1] == [:putobject, [true]]
+              break unless @insns[j + 2][0] == :getconstant # TODO: support A::B::C
+              break unless @insns[j + 3] == [:topn, [1]]
+              break unless @insns[j + 4] == [:send, [{:mid=>:===, :flag=>20, :orig_argc=>1}, nil]]
+              break unless @insns[j + 5][0] == :branch
+              target_pc = @insns[j + 5][1][1]
+              break unless @insns[target_pc] == [:pop, []]
+              nops << (j + 4) #<< target_pc
+              new_insns << [j + 5, [:arg_getlocal_send_branch, [getlocal_operands, @insns[j + 4][1], @insns[j + 5][1]]]]
+              j += 6
+            when [:pop, []]
+              #nops << j
+              case_branch_list << [nops, new_insns]
+              break
+            else
+              break
+            end
+          end
+        end
+      end
+      case_branch_list.each do |nops, new_insns|
+        nops.each {|i| @insns[i] = [:nop, []] }
+        new_insns.each {|i, insn| @insns[i] = insn }
+      end
+
+      # find a pattern: getlocal(recv), ..., send (is_a?, respond_to?), branch
+      recv_getlocal_send_branch_list = []
       (@insns.size - 1).times do |i|
         insn, operands = @insns[i]
         if insn == :getlocal && operands[1] == 0
@@ -216,7 +284,7 @@ module TypeProf
           while @insns[j]
             sp = check_send_branch(sp, j)
             if sp == :match
-              send_branch_list << [i, j]
+              recv_getlocal_send_branch_list << [i, j]
               break
             end
             break if !sp
@@ -224,13 +292,54 @@ module TypeProf
           end
         end
       end
-      send_branch_list.each do |i, j|
+      recv_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] = [:recv_getlocal_send_branch, [getlocal_operands, send_operands, branch_operands]]
+      end
+
+      # find a pattern: getlocal, send (===), branch
+      arg_getlocal_send_branch_list = []
+      (@insns.size - 1).times do |i|
+        insn1, operands1 = @insns[i]
+        next unless insn1 == :getlocal && operands1[1] == 0
+        insn2, operands2 = @insns[i + 1]
+        next unless insn2 == :send
+        send_opt = operands2[0]
+        next unless send_opt[:flag] == 16 && send_opt[:orig_argc] == 1
+        insn3, _operands3 = @insns[i + 2]
+        next unless insn3 == :branch
+        arg_getlocal_send_branch_list << i
+      end
+      arg_getlocal_send_branch_list.each do |i|
+        next if (i .. i + 2).any? {|i| branch_targets[i] }
+        _insn, getlocal_operands = @insns[i]
+        _insn, send_operands = @insns[i + 1]
+        _insn, branch_operands = @insns[i + 2]
+        @insns[i + 1] = [:nop]
+        @insns[i + 2] = [:arg_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
@@ -267,42 +376,6 @@ module TypeProf
           @insns[i + 1] = [:getlocal_branch, [getlocal_operands, branch_operands]]
         end
       end
-
-      # flow-sensitive analysis for `case var; when A; when B; when C; end`
-      # find a pattern: getlocal, (dup, putobject(true), getconstant(class name), checkmatch, branch)*
-      case_branch_list = []
-      (@insns.size - 1).times do |i|
-        insn0, getlocal_operands = @insns[i]
-        next unless [:getlocal, :getblockparam, :getblockparamproxy].include?(insn0) && getlocal_operands[1] == 0
-        nops = [i]
-        new_insns = []
-        j = i + 1
-        while true
-          case @insns[j]
-          when [:dup, []]
-            break unless @insns[j + 1] == [:putnil, []]
-            break unless @insns[j + 2] == [:putobject, [true]]
-            break unless @insns[j + 3][0] == :getconstant # TODO: support A::B::C
-            break unless @insns[j + 4] == [:checkmatch, [2]]
-            break unless @insns[j + 5][0] == :branch
-            target_pc = @insns[j + 5][1][1]
-            break unless @insns[target_pc] == [:pop, []]
-            nops << j << (j + 4) << target_pc
-            new_insns << [j + 5, [:getlocal_checkmatch_branch, [getlocal_operands, @insns[j + 5][1]]]]
-            j += 6
-          when [:pop, []]
-            nops << j
-            case_branch_list << [nops, new_insns]
-            break
-          else
-            break
-          end
-        end
-      end
-      case_branch_list.each do |nops, new_insns|
-        nops.each {|i| @insns[i] = [:nop, []] }
-        new_insns.each {|i, insn| @insns[i] = insn }
-      end
     end
 
     def check_send_branch(sp, j)
@@ -348,6 +421,8 @@ module TypeProf
         sp -= argc
         return :match if insn == :send && sp == 0 && @insns[j + 1][0] == :branch
         sp += 1
+      when :arg_getlocal_send_branch
+        return # not implemented
       when :invokeblock
         opt, = operands
         sp -= opt[:orig_argc]