typeprof 0.5.1 → 0.6.1

data/lib/typeprof/config.rb

@@ -69,19 +69,23 @@ module TypeProf
     prologue_ep = ExecutionPoint.new(prologue_ctx, -1, nil)
     prologue_env = Env.new(StaticEnv.new(:top, Type.nil, false), [], [], Utils::HashWrapper.new({}))
 
-    Config.rb_files.each do |file|
-      if file.respond_to?(:read)
-        iseq = ISeq.compile_str(file.read, file.to_s)
+    Config.rb_files.each do |rb|
+      if rb.is_a?(Array) # [String name, String content]
+        iseq = ISeq.compile_str(*rb.reverse)
       else
-        iseq = ISeq.compile(file)
+        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 |path|
-      Import.import_rbs_file(scratch, path)
+    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
     end
 
     result = scratch.type_profile

data/lib/typeprof/container-type.rb

@@ -85,7 +85,7 @@ module TypeProf
         Cell.new(@elems.limit_size(limit - 1), @base_type)
       end
 
-      def get_method(mid, scratch)
+      def method_dispatch_info
         raise
       end
 
@@ -214,8 +214,8 @@ module TypeProf
         end
       end
 
-      def get_method(mid, scratch)
-        @base_type.get_method(mid, scratch)
+      def method_dispatch_info
+        @base_type.method_dispatch_info
       end
     end
 
@@ -255,7 +255,7 @@ module TypeProf
         Array.new(@elems.limit_size(limit - 1), @base_type)
       end
 
-      def get_method(mid, scratch)
+      def method_dispatch_info
         raise
       end
 
@@ -306,6 +306,9 @@ module TypeProf
 
         def screen_name(scratch)
           if Config.options[:show_container_raw_elements] || @rest_ty == Type.bot
+            if @lead_tys.empty?
+              return "Array[bot]" # RBS does not allow an empty tuple "[]"
+            end
             s = @lead_tys.map do |ty|
               ty.screen_name(scratch)
             end
@@ -527,8 +530,8 @@ module TypeProf
         end
       end
 
-      def get_method(mid, scratch)
-        @base_type.get_method(mid, scratch)
+      def method_dispatch_info
+        @base_type.method_dispatch_info
       end
     end
 
@@ -562,7 +565,7 @@ module TypeProf
         Hash.new(@elems.limit_size(limit - 1), @base_type)
       end
 
-      def get_method(mid, scratch)
+      def method_dispatch_info
         raise
       end
 
@@ -631,16 +634,22 @@ module TypeProf
         end
 
         def screen_name(scratch)
-          s = @map_tys.map do |k_ty, v_ty|
-            v = v_ty.screen_name(scratch)
-            if k_ty.is_a?(Type::Symbol)
+          if !@map_tys.empty? && @map_tys.all? {|k_ty,| k_ty.is_a?(Type::Symbol) }
+            s = @map_tys.map do |k_ty, v_ty|
+              v = v_ty.screen_name(scratch)
               "#{ k_ty.sym }: #{ v }"
-            else
-              k = k_ty.screen_name(scratch)
-              "#{ k }=>#{ v }"
+            end.join(", ")
+            "{#{ s }}"
+          else
+            k_ty = v_ty = Type.bot
+            @map_tys.each do |k, v|
+              k_ty = k_ty.union(k)
+              v_ty = v_ty.union(v)
             end
-          end.join(", ")
-          "{#{ s }}"
+            k_ty = k_ty.screen_name(scratch)
+            v_ty = v_ty.screen_name(scratch)
+            "Hash[#{ k_ty }, #{ v_ty }]"
+          end
         end
 
         def pretty_print(q)
@@ -806,8 +815,8 @@ module TypeProf
         end
       end
 
-      def get_method(mid, scratch)
-        @base_type.get_method(mid, scratch)
+      def method_dispatch_info
+        @base_type.method_dispatch_info
       end
     end
   end

data/lib/typeprof/export.rb

@@ -91,9 +91,9 @@ module TypeProf
     def conv_class(namespace, class_def, inner_classes)
       @scratch.namespace = namespace
 
-      if class_def.superclass
-        omit = @class_defs[class_def.superclass].klass_obj == Type::Builtin[:obj] || class_def.klass_obj == Type::Builtin[:obj]
-        superclass = omit ? nil : @scratch.get_class_name(@class_defs[class_def.superclass].klass_obj)
+      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)
       end
 
       @scratch.namespace = class_def.name
@@ -105,12 +105,12 @@ module TypeProf
         consts[name] = ty.screen_name(@scratch)
       end
 
-      included_mods = class_def.modules[false].filter_map do |mod_def, absolute_paths|
+      included_mods = class_def.modules[false].filter_map do |mod_def, _type_args, absolute_paths|
         next if absolute_paths.all? {|path| !path || Config.check_dir_filter(path) == :exclude }
         Type::Instance.new(mod_def.klass_obj).screen_name(@scratch)
       end
 
-      extended_mods = class_def.modules[true].filter_map do |mod_def, absolute_paths|
+      extended_mods = class_def.modules[true].filter_map do |mod_def, _type_args, absolute_paths|
         next if absolute_paths.all? {|path| !path || Config.check_dir_filter(path) == :exclude }
         Type::Instance.new(mod_def.klass_obj).screen_name(@scratch)
       end
@@ -174,7 +174,7 @@ module TypeProf
       cvars = cvars.map do |var, entry|
         next if entry.absolute_paths.all? {|path| Config.check_dir_filter(path) == :exclude }
         [var, entry.type.screen_name(@scratch), entry.rbs_declared]
-      end
+      end.compact
 
       if !class_def.absolute_path || Config.check_dir_filter(class_def.absolute_path) == :exclude
         return nil if consts.empty? && included_mods.empty? && extended_mods.empty? && ivars.empty? && cvars.empty? && iseq_methods.empty? && attr_methods.empty? && inner_classes.empty?

data/lib/typeprof/import.rb

@@ -10,7 +10,10 @@ module TypeProf
     def self.get_builtin_env
       unless @builtin_env
         @builtin_env = RBS::Environment.new
-        @builtin_env_json = load_rbs(@builtin_env, builtin: true)
+
+        loader = RBS::EnvironmentLoader.new
+        new_decls = loader.load(env: @builtin_env).map {|decl,| decl }
+        @builtin_env_json = load_rbs(@builtin_env, new_decls)
       end
 
       return @builtin_env.dup, @builtin_env_json
@@ -21,27 +24,34 @@ module TypeProf
     end
 
     def load_library(lib)
-      RBSReader.load_rbs(@env, library: lib)
+      loader = RBS::EnvironmentLoader.new(core_root: nil)
+      loader.add(library: lib)
+      new_decls = loader.load(env: @env).map {|decl,| decl }
+      RBSReader.load_rbs(@env, new_decls)
     end
 
     def load_path(path)
-      RBSReader.load_rbs(@env, path: path)
+      loader = RBS::EnvironmentLoader.new(core_root: nil)
+      loader.add(path: path)
+      new_decls = loader.load(env: @env).map {|decl,| decl }
+      RBSReader.load_rbs(@env, new_decls)
     end
 
-    def self.load_rbs(env, builtin: false, **opt)
-      if builtin
-        loader = RBS::EnvironmentLoader.new
-      else
-        loader = RBS::EnvironmentLoader.new(core_root: nil)
-        loader.add(**opt)
+    def load_rbs_string(name, content)
+      buffer = RBS::Buffer.new(name: name, content: content)
+      new_decls = []
+      RBS::Parser.parse_signature(buffer).each do |decl|
+        @env << decl
+        new_decls << decl
       end
-      new_decls = loader.load(env: env)
+      RBSReader.load_rbs(@env, new_decls)
+    end
 
+    def self.load_rbs(env, new_decls)
       all_env = env.resolve_type_names
-
       resolver = RBS::TypeNameResolver.from_env(all_env)
       cur_env = RBS::Environment.new
-      new_decls.each do |decl,|
+      new_decls.each do |decl|
         cur_env << env.resolve_declaration(resolver, decl, outer: [], prefix: RBS::Namespace.root)
       end
 
@@ -52,6 +62,7 @@ module TypeProf
   class RBS2JSON
     def initialize(all_env, cur_env)
       @all_env, @cur_env = all_env, cur_env
+      @env_walker = RBS::EnvironmentWalker.new(env: @cur_env) # Currently, only each_type_name is used
     end
 
     def dump_json
@@ -90,9 +101,13 @@ module TypeProf
       json = {}
 
       each_class_decl do |name, decls|
-        super_class_name = get_super_class_name(name, decls)
         klass = conv_type_name(name)
-        superclass = super_class_name ? conv_type_name(super_class_name) : nil
+        super_class_name, super_class_args = get_super_class(name, decls)
+        if super_class_name
+          name = conv_type_name(super_class_name)
+          type_args = super_class_args.map {|type| conv_type(type) }
+          superclass = [name, type_args]
+        end
 
         type_params = nil
         included_modules = []
@@ -155,7 +170,8 @@ module TypeProf
               name = member.name
               if name.kind == :class
                 mod = conv_type_name(name)
-                included_modules << mod
+                type_args = member.args.map {|type| conv_type(type) }
+                included_modules << [mod, type_args]
               else
                 # including an interface is not supported yet
               end
@@ -164,7 +180,8 @@ module TypeProf
               name = member.name
               if name.kind == :class
                 mod = conv_type_name(name)
-                extended_modules << mod
+                type_args = member.args.map {|type| conv_type(type) }
+                extended_modules << [mod, type_args]
               else
                 # extending a module with an interface is not supported yet
               end
@@ -221,7 +238,7 @@ module TypeProf
             @all_env.class_decls[name].decls.each do |decl|
               decl = decl.decl
               next if decl.is_a?(RBS::AST::Declarations::Module)
-              each_ancestor(decl) {|name| queue << [:visit, name] }
+              each_reference(decl) {|name| queue << [:visit, name] }
             end
             queue << [:visit, name.namespace.to_type_name] if !name.namespace.empty?
           end
@@ -236,24 +253,35 @@ module TypeProf
       end
     end
 
-    def each_ancestor(decl, &blk)
+    def each_reference(decl, &blk)
       yield decl.name
-      super_class = decl.super_class || RBS::BuiltinNames::Object
+      if decl.super_class
+        name = decl.super_class.name
+        args = decl.super_class.args
+        if args
+          args.each do |ty|
+            @env_walker.each_type_name(ty, &blk)
+          end
+        end
+      else
+        name = RBS::BuiltinNames::Object.name
+      end
       return if decl.name == RBS::BuiltinNames::BasicObject.name
-      return if decl.name == super_class.name
-      @all_env.class_decls[super_class.name].decls.each do |decl|
-        each_ancestor(decl.decl, &blk)
+      return if decl.name == name
+      @all_env.class_decls[name].decls.each do |decl|
+        each_reference(decl.decl, &blk)
       end
     end
 
-    def get_super_class_name(name, decls)
+    def get_super_class(name, decls)
       return nil if name == RBS::BuiltinNames::BasicObject.name
 
       decls.each do |decl|
         decl = decl.decl
         case decl
         when RBS::AST::Declarations::Class
-          return decl.super_class.name if decl.super_class
+          super_class = decl.super_class
+          return super_class.name, super_class.args if super_class
         when RBS::AST::Declarations::Module, RBS::AST::Declarations::Interface
           return nil
         else
@@ -261,7 +289,7 @@ module TypeProf
         end
       end
 
-      return RBS::BuiltinNames::Object.name
+      return RBS::BuiltinNames::Object.name, []
     end
 
     def conv_method_def(rbs_method_types)
@@ -445,6 +473,10 @@ module TypeProf
       Import.new(scratch, scratch.rbs_reader.load_path(rbs_path)).import(true)
     end
 
+    def self.import_rbs_code(scratch, rbs_name, rbs_code)
+      Import.new(scratch, scratch.rbs_reader.load_rbs_string(rbs_name, rbs_code)).import(true)
+    end
+
     def initialize(scratch, json)
       @scratch = scratch
       @json = json
@@ -453,8 +485,8 @@ module TypeProf
     def import(explicit = false)
       classes = @json[:classes].map do |classpath, cdef|
         type_params = cdef[:type_params]
-        superclass  = cdef[:superclass]
-        members     = cdef[:members]
+        superclass, superclass_type_args = cdef[:superclass]
+        members = cdef[:members]
 
         name = classpath.last
         superclass = path_to_klass(superclass) if superclass
@@ -462,7 +494,8 @@ module TypeProf
 
         klass = @scratch.get_constant(base_klass, name)
         if klass.is_a?(Type::Any)
-          klass = @scratch.new_class(base_klass, name, type_params, superclass, nil)
+          superclass_type_args = superclass_type_args&.map {|ty| conv_type(ty) }
+          klass = @scratch.new_class(base_klass, name, type_params, superclass, superclass_type_args, nil)
 
           # There builtin classes are needed to interpret RBS declarations
           case classpath
@@ -489,12 +522,14 @@ module TypeProf
         cvars = members[:cvars]
         rbs_sources = members[:rbs_sources]
 
-        included_modules.each do |mod|
-          @scratch.include_module(klass, path_to_klass(mod), nil)
+        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|
-          @scratch.extend_module(klass, path_to_klass(mod), nil)
+        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)
         end
 
         methods.each do |(singleton, method_name), mdef|

data/lib/typeprof/method.rb

@@ -170,6 +170,34 @@ module TypeProf
 
     def do_send(recv_orig, mid, aargs, caller_ep, caller_env, scratch, &ctn)
       recv = scratch.globalize_type(recv_orig, caller_env, caller_ep)
+
+      tmp_subst = {}
+      case
+      when recv.is_a?(Type::Cell) && recv_orig.is_a?(Type::LocalCell)
+        tyvars = recv.base_type.klass.type_params.map {|name,| Type::Var.new(name) }
+        tyvars.zip(recv.elems.elems) do |tyvar, elem|
+          if tmp_subst[tyvar]
+            tmp_subst[tyvar] = tmp_subst[tyvar].union(elem)
+          else
+            tmp_subst[tyvar] = elem
+          end
+        end
+      when recv.is_a?(Type::Array) && recv_orig.is_a?(Type::LocalArray)
+        tmp_subst = { Type::Var.new(:Elem) => recv.elems.squash }
+      when recv.is_a?(Type::Hash) && recv_orig.is_a?(Type::LocalHash)
+        tyvar_k = Type::Var.new(:K)
+        tyvar_v = Type::Var.new(:V)
+        k_ty0, v_ty0 = recv.elems.squash
+        # XXX: need to heuristically replace ret type Hash[K, V] with self, instead of conversative type?
+        tmp_subst = { tyvar_k => k_ty0, tyvar_v => v_ty0 }
+      end
+
+      klass, singleton = recv_orig.method_dispatch_info
+      cur_subst = {}
+      scratch.generate_substitution(klass, singleton, mid, self, tmp_subst) do |subst|
+        cur_subst = Type.merge_substitution(cur_subst, subst)
+      end
+
       found = false
       aargs = scratch.globalize_type(aargs, caller_env, caller_ep)
       @sig_rets.each do |msig, ret_ty|
@@ -178,11 +206,10 @@ module TypeProf
         # XXX: support self type in msig
         subst = aargs.consistent_with_method_signature?(msig)
         next unless subst
-        # need to check self tyvar?
-        subst[Type::Var.new(:self)] = recv
         case
         when recv.is_a?(Type::Cell) && recv_orig.is_a?(Type::LocalCell)
           tyvars = recv.base_type.klass.type_params.map {|name,| Type::Var.new(name) }
+          # XXX: This should be skipped when the called methods belongs to superclass
           tyvars.each_with_index do |tyvar, idx|
             ty = subst[tyvar]
             if ty
@@ -192,13 +219,6 @@ module TypeProf
               end
             end
           end
-          tyvars.zip(recv.elems.elems) do |tyvar, elem|
-            if subst[tyvar]
-              subst[tyvar] = subst[tyvar].union(elem)
-            else
-              subst[tyvar] = elem
-            end
-          end
         when recv.is_a?(Type::Array) && recv_orig.is_a?(Type::LocalArray)
           tyvar_elem = Type::Var.new(:Elem)
           if subst[tyvar_elem]
@@ -208,16 +228,12 @@ module TypeProf
               elems.update(nil, ty)
             end
           end
-          subst.merge!({ tyvar_elem => recv.elems.squash })
         when recv.is_a?(Type::Hash) && recv_orig.is_a?(Type::LocalHash)
           tyvar_k = Type::Var.new(:K)
           tyvar_v = Type::Var.new(:V)
-          k_ty0, v_ty0 = recv.elems.squash
           if subst[tyvar_k] && subst[tyvar_v]
             k_ty = subst[tyvar_k]
             v_ty = subst[tyvar_v]
-            k_ty0 = k_ty0.union(k_ty)
-            v_ty0 = v_ty0.union(v_ty)
             alloc_site = AllocationSite.new(caller_ep)
             ncaller_env, k_ty = scratch.localize_type(k_ty, ncaller_env, caller_ep, alloc_site.add_id(:k))
             ncaller_env, v_ty = scratch.localize_type(v_ty, ncaller_env, caller_ep, alloc_site.add_id(:v))
@@ -225,9 +241,10 @@ module TypeProf
               elems.update(k_ty, v_ty)
             end
           end
-          # XXX: need to heuristically replace ret type Hash[K, V] with self, instead of conversative type?
-          subst.merge!({ tyvar_k => k_ty0, tyvar_v => v_ty0 })
         end
+        subst = Type.merge_substitution(subst, cur_subst)
+        # need to check self tyvar?
+        subst[Type::Var.new(:self)] = recv
         found = true
         if aargs.blk_ty.is_a?(Type::Proc)
           #raise NotImplementedError unless aargs.blk_ty.block_body.is_a?(ISeqBlock) # XXX