typeprof 0.5.0 → 0.6.0

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
 
@@ -90,9 +100,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 +169,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 +179,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
@@ -246,14 +262,15 @@ module TypeProf
       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 +278,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 +462,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 +474,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 +483,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 +511,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

data/lib/typeprof/type.rb

@@ -170,7 +170,7 @@ module TypeProf
         "untyped"
       end
 
-      def get_method(mid, scratch)
+      def method_dispatch_info
         nil
       end
 
@@ -430,15 +430,17 @@ module TypeProf
     end
 
     class Class < Type # or Module
-      def initialize(kind, idx, type_params, superclass, name)
+      def initialize(kind, idx, type_params, superclass, superclass_type_args, name)
         @kind = kind # :class | :module
         @idx = idx
         @type_params = type_params
         @superclass = superclass
+        raise if @kind == :class && !@superclass
+        @superclass_type_args = superclass_type_args
         @_name = name
       end
 
-      attr_reader :kind, :idx, :type_params, :superclass
+      attr_reader :kind, :idx, :type_params, :superclass, :superclass_type_args
 
       def inspect
         if @_name
@@ -449,11 +451,11 @@ module TypeProf
       end
 
       def screen_name(scratch)
-        "#{ scratch.get_class_name(self) }.class"
+        "singleton(#{ scratch.get_class_name(self) })"
       end
 
-      def get_method(mid, scratch)
-        scratch.get_method(self, true, mid)
+      def method_dispatch_info
+        [self, true]
       end
 
       def consistent?(other)
@@ -504,8 +506,8 @@ module TypeProf
         end
       end
 
-      def get_method(mid, scratch)
-        scratch.get_method(@klass, false, mid)
+      def method_dispatch_info
+        [@klass, false]
       end
 
       def consistent?(other)
@@ -558,8 +560,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
 
       def substitute(subst, depth)
@@ -600,8 +602,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
 
       def substitute(_subst, _depth)
@@ -630,8 +632,8 @@ module TypeProf
         @base_type
       end
 
-      def get_method(mid, scratch)
-        @base_type.get_method(mid, scratch)
+      def method_dispatch_info
+        @base_type.method_dispatch_info
       end
 
       def consistent?(_other)
@@ -785,6 +787,10 @@ module TypeProf
       end
       str = str.empty? ? "" : "(#{ str.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" }
+
       optional = false
       blks = []
       @blk_ty.each_child_global do |ty|