typeprof 0.5.4 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2d60066fe3965ec65f9885e311f856277d0e41330478489c026fdf6b387ba2ba
-  data.tar.gz: 963b66fe97d98207d72645011bcd012368937ded76278d92a4b677b961c92cdc
+  metadata.gz: '080db9120b2b069f8a1385e3696851212a2271652f73b8627d5337d2d26d8f2b'
+  data.tar.gz: 969e38b2a1b64ec3fbe90551b440418901c8af028c7126b1f56acaca3818d2b1
 SHA512:
-  metadata.gz: a40e89e05c1680480eb66798863ab99a4b38b3faaacdc471a6cdd45dfc1f897efcc8f613800ef28e5bc722c3504dec510ca943435873b6cb765a27f1bb073425
-  data.tar.gz: 94dddf2c3e465ee19093ce571d50440293118b07ab7c90203aa5ccb40c4f9eb9afe1059eff045c965006affa8f0d66d141be2064feddf9a2b1f8384f8cadae64
+  metadata.gz: 322bff1d2a49e9a2729012064e393138cb9e4b81472e1c75b14a2d55a4fe3616ef3efc5ecf5df3a156a418ff6ad0281c24c2c585c61a733db0c6e4d05ceb6595
+  data.tar.gz: 78de3b56104b239c272938a9877bfdd49ccf20df8dbd360bf5fe7ef3c342e1d746c2adbf957fd511c03156258effe630c440941e600d58b7e7cd914ff11ca4d5

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    typeprof (0.5.4)
+    typeprof (0.6.0)
       rbs (>= 0.17.0)
 
 GEM

data/lib/typeprof/analyzer.rb

@@ -281,11 +281,10 @@ module TypeProf
     attr_reader :class_defs
 
     class ClassDef # or ModuleDef
-      def initialize(kind, name, superclass, absolute_path)
+      def initialize(kind, name, absolute_path)
         raise unless name.is_a?(Array)
         @kind = kind
-        @superclass = superclass
-        @modules = { true => {}, false => {} }
+        @modules = { true => [], false => [] }
         @name = name
         @consts = {}
         @methods = {}
@@ -295,14 +294,16 @@ module TypeProf
         @namespace = nil
       end
 
-      attr_reader :kind, :superclass, :modules, :consts, :methods, :ivars, :cvars, :absolute_path
+      attr_reader :kind, :modules, :consts, :methods, :ivars, :cvars, :absolute_path
       attr_accessor :name, :klass_obj
 
-      def include_module(mod, singleton, absolute_path)
-        # XXX: need to check if mod is already included by the ancestors?
-        absolute_paths = @modules[singleton][mod]
-        unless absolute_paths
-          @modules[singleton][mod] = absolute_paths = Utils::MutableSet.new
+      def include_module(mod, type_args, singleton, absolute_path)
+        module_type_args, _, absolute_paths = @modules[singleton].find {|m,| m == mod }
+        if module_type_args
+          raise "inconsistent include/extend type args in RBS?" if module_type_args != type_args && type_args != [] && type_args != nil
+        else
+          absolute_paths = Utils::MutableSet.new
+          @modules[singleton].unshift([mod, type_args, absolute_paths])
         end
         absolute_paths << absolute_path
       end
@@ -319,13 +320,26 @@ module TypeProf
         @consts[name] = [ty, absolute_path]
       end
 
-      def get_method(mid, singleton)
-        @methods[[singleton, mid]] || begin
-          @modules[singleton].each_key do |mod|
-            meth = mod.get_method(mid, false)
-            return meth if meth
+      def generate_substitution(singleton, mid, mthd, subst, &blk)
+        mthds = @methods[[singleton, mid]]
+        yield subst if mthds&.include?(mthd)
+        @modules[singleton].each do |mod_def, type_args,|
+          if mod_def.klass_obj.type_params && type_args
+            subst2 = {}
+            mod_def.klass_obj.type_params.zip(type_args) do |(tyvar, *), tyarg|
+              tyvar = Type::Var.new(tyvar)
+              subst2[tyvar] = tyarg.substitute(subst, Config.options[:type_depth_limit])
+            end
+            mod_def.generate_substitution(false, mid, mthd, subst2, &blk)
           end
-          nil
+        end
+      end
+
+      def search_method(singleton, mid, &blk)
+        mthds = @methods[[singleton, mid]]
+        yield mthds, @klass_obj, singleton if mthds
+        @modules[singleton].each do |mod_def,|
+          mod_def.search_method(false, mid, &blk)
         end
       end
 
@@ -349,7 +363,7 @@ module TypeProf
       end
     end
 
-    def include_module(including_mod, included_mod, singleton, absolute_path)
+    def include_module(including_mod, included_mod, type_args, singleton, absolute_path)
       return if included_mod == Type.any
 
       including_mod = @class_defs[including_mod.idx]
@@ -357,7 +371,7 @@ module TypeProf
         if included_mod.is_a?(Type::Class)
           included_mod = @class_defs[included_mod.idx]
           if included_mod && included_mod.kind == :module
-            including_mod.include_module(included_mod, singleton, absolute_path)
+            including_mod.include_module(included_mod, type_args, singleton, absolute_path)
           else
             warn "including something that is not a module"
           end
@@ -369,25 +383,20 @@ module TypeProf
       cbase && cbase.idx != 1 ? @class_defs[cbase.idx].name : []
     end
 
-    def new_class(cbase, name, type_params, superclass, absolute_path)
+    def new_class(cbase, name, type_params, superclass, superclass_type_args, absolute_path)
       show_name = cbase_path(cbase) + [name]
       idx = @class_defs.size
       if superclass
-        if superclass == :__root__
-          superclass_idx = superclass = nil
-        else
-          superclass_idx = superclass.idx
-        end
-        @class_defs[idx] = ClassDef.new(:class, show_name, superclass_idx, absolute_path)
-        klass = Type::Class.new(:class, idx, type_params, superclass, show_name)
+        @class_defs[idx] = ClassDef.new(:class, show_name, absolute_path)
+        klass = Type::Class.new(:class, idx, type_params, superclass, superclass_type_args, show_name)
         @class_defs[idx].klass_obj = klass
         cbase ||= klass # for bootstrap
         add_constant(cbase, name, klass, absolute_path)
         return klass
       else
         # module
-        @class_defs[idx] = ClassDef.new(:module, show_name, nil, absolute_path)
-        mod = Type::Class.new(:module, idx, type_params, nil, show_name)
+        @class_defs[idx] = ClassDef.new(:module, show_name, absolute_path)
+        mod = Type::Class.new(:module, idx, type_params, nil, nil, show_name)
         @class_defs[idx].klass_obj = mod
         add_constant(cbase, name, mod, absolute_path)
         return mod
@@ -400,8 +409,8 @@ module TypeProf
       idx = @class_defs.size
       superclass = Type::Builtin[:struct]
       name = "AnonymousStruct_generated_#{ @anonymous_struct_gen_id += 1 }"
-      @class_defs[idx] = ClassDef.new(:class, [name], superclass.idx, ep.ctx.iseq.absolute_path)
-      klass = Type::Class.new(:class, idx, [], superclass, name)
+      @class_defs[idx] = ClassDef.new(:class, [name], ep.ctx.iseq.absolute_path)
+      klass = Type::Class.new(:class, idx, [], superclass, [], name)
       @class_defs[idx].klass_obj = klass
 
       @struct_defs[ep] = klass
@@ -431,28 +440,75 @@ module TypeProf
       end
     end
 
+    def generate_substitution(klass, singleton, mid, mthd, subst, &blk)
+      if klass.kind == :class
+        while klass != :__root__
+          class_def = @class_defs[klass.idx]
+          class_def.generate_substitution(singleton, mid, mthd, subst, &blk)
+          if klass.superclass && klass.superclass_type_args
+            subst2 = {}
+            klass.superclass.type_params.zip(klass.superclass_type_args) do |(tyvar, *), tyarg|
+              tyvar = Type::Var.new(tyvar)
+              subst2[tyvar] = tyarg.substitute(subst, Config.options[:type_depth_limit])
+            end
+            subst = subst2
+          end
+          klass = klass.superclass
+        end
+      else
+        # module
+        class_def = @class_defs[klass.idx]
+        class_def.generate_substitution(singleton, mid, mthd, subst, &blk)
+      end
+    end
+
+    def search_method(klass, singleton, mid, &blk)
+      # XXX: support method alias correctly
+      klass_orig = klass
+      if klass.kind == :class
+        while klass != :__root__
+          class_def = @class_defs[klass.idx]
+          class_def.search_method(singleton, mid, &blk)
+          klass = klass.superclass
+        end
+      else
+        # module
+        class_def = @class_defs[klass.idx]
+        class_def.search_method(singleton, mid, &blk)
+      end
+      if singleton
+        search_method(Type::Builtin[klass_orig.kind], false, mid, &blk)
+      end
+    end
+
     def get_method(klass, singleton, mid)
-      idx = klass.idx
-      while idx
-        class_def = @class_defs[idx]
-        mthd = class_def.get_method(mid, singleton)
-        # Need to be conservative to include all super candidates...?
-        return mthd if mthd
-        idx = class_def.superclass
+      search_method(klass, singleton, mid) {|mthds,| return mthds }
+    end
+
+    def get_all_super_methods(klass, singleton, current_klass, mid)
+      hit = false
+      search_method(klass, singleton, mid) do |mthds, klass0, singleton0|
+        yield mthds, klass0, singleton0 if hit
+        hit = klass0 == current_klass
       end
-      return get_method(Type::Builtin[:class], false, mid) if singleton
-      nil
     end
 
     def get_super_method(ctx, singleton)
-      idx = ctx.cref.klass.idx
+      klass = ctx.cref.klass
       mid = ctx.mid
-      idx = @class_defs[idx].superclass
-      while idx
-        class_def = @class_defs[idx]
+      if klass.kind == :class
+        klass = klass.superclass
+        while klass != :__root__
+          class_def = @class_defs[klass.idx]
+          mthd = class_def.get_method(mid, singleton)
+          return mthd if mthd
+          klass = klass.superclass
+        end
+      else
+        # module
+        class_def = @class_defs[klass.idx]
         mthd = class_def.get_method(mid, singleton)
         return mthd if mthd
-        idx = class_def.superclass
       end
       nil
     end
@@ -1157,7 +1213,8 @@ module TypeProf
             if cbase == Type.any
               klass = Type.any
             else
-              klass = new_class(cbase, id, [], superclass, ep.ctx.iseq.absolute_path)
+              superclass_type_args = superclass.type_params.map { Type.any } if superclass
+              klass = new_class(cbase, id, [], superclass, superclass_type_args, ep.ctx.iseq.absolute_path)
             end
           end
           singleton = false
@@ -1245,30 +1302,30 @@ module TypeProf
         end
       when :invokesuper
         env, recv, _, aargs = setup_actual_arguments(:method, operands, ep, env)
-
-        env, recv = localize_type(env.static_env.recv_ty, env, ep)
-        mid  = ep.ctx.mid
-        singleton = !recv.is_a?(Type::Instance) # TODO: any?
-        # XXX: need to support included module...
-        meths = get_super_method(ep.ctx, singleton) # TODO: multiple return values
-        if meths
-          meths.each do |meth|
-            # XXX: this decomposition is really needed??
-            # It calls `Object.new` with union receiver which causes an error, but
-            # it may be a fault of builtin Object.new implementation.
-            recv.each_child do |recv|
-              meth.do_send(recv, mid, aargs, ep, env, self) do |ret_ty, ep, env|
-                nenv, ret_ty, = localize_type(ret_ty, env, ep)
-                nenv = nenv.push(ret_ty)
-                merge_env(ep.next, nenv)
+        mid = ep.ctx.mid
+        found = false
+        recv.each_child_global do |recv|
+          klass, singleton = recv.method_dispatch_info
+          next unless klass
+          get_all_super_methods(klass, singleton, ep.ctx.cref.klass, ep.ctx.mid) do |meths, klass|
+            found = true
+            meths.each do |meth|
+              # XXX: this decomposition is really needed??
+              # It calls `Object.new` with union receiver which causes an error, but
+              # it may be a fault of builtin Object.new implementation.
+              recv.each_child do |recv|
+                meth.do_send(recv, mid, aargs, ep, env, self) do |ret_ty, ep, env|
+                  nenv, ret_ty, = localize_type(ret_ty, env, ep)
+                  nenv = nenv.push(ret_ty)
+                  merge_env(ep.next, nenv)
+                end
               end
             end
           end
-          return
-        else
-          error(ep, "no superclass method: #{ env.static_env.recv_ty.screen_name(self) }##{ mid }")
-          env = env.push(Type.any)
         end
+        return if found
+        error(ep, "no superclass method: #{ env.static_env.recv_ty.screen_name(self) }##{ mid }")
+        env = env.push(Type.any)
       when :invokebuiltin
         raise NotImplementedError
       when :leave
@@ -1916,7 +1973,8 @@ module TypeProf
     end
 
     def do_send(recv, mid, aargs, ep, env, &ctn)
-      meths = recv.get_method(mid, self)
+      klass, singleton = recv.method_dispatch_info
+      meths = get_method(klass, singleton, mid) if klass
       if meths
         meths.each do |meth|
           meth.do_send(recv, mid, aargs, ep, env, self, &ctn)

data/lib/typeprof/builtin.rb

@@ -100,7 +100,8 @@ module TypeProf
       raise unless aargs.lead_tys.size != 0
       sym = get_sym("respond_to?", aargs.lead_tys[0], ep, scratch)
       if sym
-        if recv.get_method(sym, scratch)
+        klass, singleton = recv.method_dispatch_info
+        if scratch.get_method(klass, singleton, sym)
           true_val = Type::Instance.new(Type::Builtin[:true])
           ctn[true_val, ep, env]
         else
@@ -143,7 +144,7 @@ module TypeProf
     def object_instance_eval(recv, mid, aargs, ep, env, scratch, &ctn)
       if aargs.lead_tys.size >= 1
         scratch.warn(ep, "instance_eval with arguments are ignored")
-        ctn[type.any, ep, env]
+        ctn[Type.any, ep, env]
         return
       end
       naargs = ActualArguments.new([recv], nil, {}, Type.nil)
@@ -153,20 +154,30 @@ module TypeProf
     end
 
     def module_include(recv, mid, aargs, ep, env, scratch, &ctn)
+      if aargs.lead_tys.size != 1
+        scratch.warn(ep, "Module#include without an argument are ignored")
+        ctn[Type.any, ep, env]
+        return
+      end
       arg = aargs.lead_tys[0]
       arg.each_child do |arg|
         if arg.is_a?(Type::Class)
-          scratch.include_module(recv, arg, false, ep.ctx.iseq.absolute_path)
+          scratch.include_module(recv, arg, nil, false, ep.ctx.iseq.absolute_path)
         end
       end
       ctn[recv, ep, env]
     end
 
     def module_extend(recv, mid, aargs, ep, env, scratch, &ctn)
+      if aargs.lead_tys.size != 1
+        scratch.warn(ep, "Module#extend without an argument are ignored")
+        ctn[Type.any, ep, env]
+        return
+      end
       arg = aargs.lead_tys[0]
       arg.each_child do |arg|
         if arg.is_a?(Type::Class)
-          scratch.include_module(recv, arg, true, ep.ctx.iseq.absolute_path)
+          scratch.include_module(recv, arg, nil, true, ep.ctx.iseq.absolute_path)
         end
       end
       ctn[recv, ep, env]
@@ -178,7 +189,7 @@ module TypeProf
       else
         aargs.lead_tys.each do |aarg|
           sym = get_sym("module_function", aarg, ep, scratch) or next
-          meths = Type::Instance.new(recv).get_method(sym, scratch)
+          meths = scratch.get_method(recv, false, sym)
           meths.each do |mdef|
             scratch.add_method(recv, sym, true, mdef)
           end
@@ -491,8 +502,8 @@ module TypeProf
     end
 
     def self.setup_initial_global_env(scratch)
-      klass_basic_obj = scratch.new_class(nil, :BasicObject, [], :__root__, nil) # cbase, name, superclass
-      klass_obj = scratch.new_class(nil, :Object, [], klass_basic_obj, nil)
+      klass_basic_obj = scratch.new_class(nil, :BasicObject, [], :__root__, nil, nil) # cbase, name, superclass
+      klass_obj = scratch.new_class(nil, :Object, [], klass_basic_obj, [], nil)
       scratch.add_constant(klass_obj, :Object, klass_obj, nil)
       scratch.add_constant(klass_obj, :BasicObject, klass_basic_obj, nil)
 
@@ -501,7 +512,7 @@ module TypeProf
 
       Import.import_builtin(scratch)
 
-      Type::Builtin[:vmcore]    = scratch.new_class(klass_obj, :VMCore, [], klass_obj, nil)
+      Type::Builtin[:vmcore]    = scratch.new_class(klass_obj, :VMCore, [], klass_obj, [], nil)
       Type::Builtin[:int]       = scratch.get_constant(klass_obj, :Integer)
       Type::Builtin[:float]     = scratch.get_constant(klass_obj, :Float)
       Type::Builtin[:rational]  = scratch.get_constant(klass_obj, :Rational)

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
 
@@ -530,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
 
@@ -565,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
 
@@ -815,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

data/lib/typeprof/import.rb

@@ -100,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 = []
@@ -165,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
@@ -174,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
@@ -256,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
@@ -271,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)
@@ -467,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
@@ -476,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
@@ -503,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), false, 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.include_module(klass, path_to_klass(mod), true, 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
@@ -452,8 +454,8 @@ module TypeProf
         "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)

data/lib/typeprof/version.rb

@@ -1,3 +1,3 @@
 module TypeProf
-  VERSION = "0.5.4"
+  VERSION = "0.6.0"
 end

data/smoke/parameterizedd-self2.rb

@@ -0,0 +1,15 @@
+class Object
+  def foo
+    # The receiver is considered as an empty array
+    self[0]
+  end
+end
+
+# The elements are dropped when it is passed as a receiver (to avoid state explosion)
+[0].foo
+
+__END__
+# Classes
+class Object
+  def foo : -> nil
+end

data/smoke/rbs-tyvar6.rb

@@ -0,0 +1,17 @@
+def log1(obj) end
+def log2(obj) end
+def log3(obj) end
+
+obj = Bar.new("str")
+
+log1(obj)
+log2(obj.test_superclass)
+log3(obj.test_module)
+
+__END__
+# Classes
+class Object
+  def log1 : (Bar[String]) -> nil
+  def log2 : (Array[String]) -> nil
+  def log3 : (Integer) -> nil
+end

data/smoke/rbs-tyvar6.rbs

@@ -0,0 +1,12 @@
+class Foo[X]
+  def test_superclass: -> X
+end
+
+module M[X]
+  def test_module: -> X
+end
+
+class Bar[X] < Foo[Array[X]]
+  def initialize: (X) -> void
+  include M[Integer]
+end

data/smoke/super4.rb

@@ -0,0 +1,43 @@
+module M1
+  def f(m); super :M1; end
+end
+module M2
+  def f(m); super :M2; end
+end
+class C
+  def f(m); end
+end
+class D < C
+  def f(m); super :D; end
+  include M1
+end
+class E < D
+  def f(m); super :E; end
+  include M2
+end
+
+E.new.f(:top)
+
+__END__
+# Classes
+module M1
+  def f : (:D) -> nil
+end
+
+module M2
+  def f : (:E) -> nil
+end
+
+class C
+  def f : (:M1) -> nil
+end
+
+class D < C
+  include M1
+  def f : (:M2) -> nil
+end
+
+class E < D
+  include M2
+  def f : (:top) -> nil
+end

data/smoke/super5.rb

@@ -0,0 +1,36 @@
+module M
+  def f(m); super :M; end
+end
+class C
+  def f(m); end
+end
+class D < C
+  def f(m); super :D; end
+  include M
+end
+class E < D
+  def f(m); super :E; end
+  include M
+end
+
+E.new.f(:top)
+
+__END__
+# Classes
+module M
+  def f : (:D | :E) -> nil
+end
+
+class C
+  def f : (:M) -> nil
+end
+
+class D < C
+  include M
+  def f : (:M) -> nil
+end
+
+class E < D
+  include M
+  def f : (:top) -> nil
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: typeprof
 version: !ruby/object:Gem::Version
-  version: 0.5.4
+  version: 0.6.0
 platform: ruby
 authors:
 - Yusuke Endoh
@@ -229,6 +229,7 @@ files:
 - smoke/optional2.rb
 - smoke/optional3.rb
 - smoke/parameterizedd-self.rb
+- smoke/parameterizedd-self2.rb
 - smoke/pathname1.rb
 - smoke/pathname2.rb
 - smoke/pattern-match1.rb
@@ -264,6 +265,8 @@ files:
 - smoke/rbs-tyvar4.rb
 - smoke/rbs-tyvar5.rb
 - smoke/rbs-tyvar5.rbs
+- smoke/rbs-tyvar6.rb
+- smoke/rbs-tyvar6.rbs
 - smoke/rbs-vars.rb
 - smoke/rbs-vars.rbs
 - smoke/redo1.rb
@@ -292,6 +295,8 @@ files:
 - smoke/super1.rb
 - smoke/super2.rb
 - smoke/super3.rb
+- smoke/super4.rb
+- smoke/super5.rb
 - smoke/svar1.rb
 - smoke/symbol-proc.rb
 - smoke/tap1.rb