typeprof 0.5.1 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d55a91519761d29aaff38516b7bd079dde1d4b21349fc23786aebacf4c0eef50
-  data.tar.gz: 61663b62730ba7405b7dbdaa2c5d662b9850f597a58439ba5d8acac287ab6b82
+  metadata.gz: 3dedfe8da717afcf508820efe445a790336ab877156d5b2de3683ab5043c18ab
+  data.tar.gz: 345fa1163af50a1b01fef26a83a835bfd7813453c6132ebb1036fe8178dd9757
 SHA512:
-  metadata.gz: eff989005f090be43e584aaeeae68edfc67dd87d09050bff061aa1e4ed3927583359540db92702040f8ab3d5353a2d48ec9e276b519964cd0c332cfd383d15c1
-  data.tar.gz: 386dc99ae9dfc4e5f06c8a606bf9ea5278500fb8a044d805d16b6e1a7524e39a66fbe7ba964b9604be3d9e573230f92e868aa0c357ebf8249c7af0a3f0daf656
+  metadata.gz: 48972d2ab935ff782a0651eda48afa301531d5c5fff4f1a9ba17d29c54323b127fc3013c29863c21b26d77e81230c2e0318d58d3cde680c57b611c5a77a1214b
+  data.tar.gz: dc29d8282f165f9ddaabecf97f4eb81aaaa43c5defe1d63d083ef1147c2c0e6d2def961fa07f339587902d8524ee66940da742a5b30cd48dcccdcd94262883a8

data/Gemfile.lock

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

data/lib/typeprof/analyzer.rb

@@ -252,6 +252,8 @@ module TypeProf
       @rbs_reader = RBSReader.new
 
       @terminated = false
+
+      @anonymous_struct_gen_id = 0
     end
 
     attr_reader :return_envs, :loaded_features, :rbs_reader
@@ -279,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 = {}
@@ -293,23 +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, absolute_path)
-        # XXX: need to check if mod is already included by the ancestors?
-        absolute_paths = @modules[false][mod]
-        unless absolute_paths
-          @modules[false][mod] = absolute_paths = Utils::MutableSet.new
-        end
-        absolute_paths << absolute_path
-      end
-
-      def extend_module(mod, absolute_path)
-        # XXX: need to check if mod is already included by the ancestors?
-        absolute_paths = @modules[true][mod]
-        unless absolute_paths
-          @modules[true][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
@@ -326,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
 
@@ -356,7 +363,7 @@ module TypeProf
       end
     end
 
-    def include_module(including_mod, included_mod, 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]
@@ -364,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, absolute_path)
+            including_mod.include_module(included_mod, type_args, singleton, absolute_path)
           else
             warn "including something that is not a module"
           end
@@ -372,43 +379,24 @@ module TypeProf
       end
     end
 
-    def extend_module(extending_mod, extended_mod, absolute_path)
-      extending_mod = @class_defs[extending_mod.idx]
-      extended_mod.each_child do |extended_mod|
-        if extended_mod.is_a?(Type::Class)
-          extended_mod = @class_defs[extended_mod.idx]
-          if extended_mod && extended_mod.kind == :module
-            extending_mod.extend_module(extended_mod, absolute_path)
-          else
-            warn "extending something that is not a module"
-          end
-        end
-      end
-    end
-
     def cbase_path(cbase)
       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
@@ -420,8 +408,9 @@ module TypeProf
 
       idx = @class_defs.size
       superclass = Type::Builtin[:struct]
-      @class_defs[idx] = ClassDef.new(:class, ["(Anonymous Struct)"], superclass.idx, ep.ctx.iseq.absolute_path)
-      klass = Type::Class.new(:class, idx, [], superclass, "(Anonymous Struct)")
+      name = "AnonymousStruct_generated_#{ @anonymous_struct_gen_id += 1 }"
+      @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
@@ -451,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
@@ -1155,35 +1191,30 @@ module TypeProf
           else
             if existing_klass != Type.any
               error(ep, "the class \"#{ id }\" is #{ existing_klass.screen_name(self) }")
-              id = :"#{ id }(dummy)"
             end
-            existing_klass = get_constant(cbase, id) # TODO: multiple return values
-            if existing_klass != Type.any
-              klass = existing_klass
-            else
-              if type == :class
-                if superclass.is_a?(Type::Class)
-                  # okay
-                elsif superclass == Type.any
-                  warn(ep, "superclass is any; Object is used instead")
-                  superclass = Type::Builtin[:obj]
-                elsif superclass == Type.nil
-                  superclass = Type::Builtin[:obj]
-                elsif superclass.is_a?(Type::Instance)
-                  warn(ep, "superclass is an instance; Object is used instead")
-                  superclass = Type::Builtin[:obj]
-                else
-                  warn(ep, "superclass is not a class; Object is used instead")
-                  superclass = Type::Builtin[:obj]
-                end
-              else # module
-                superclass = nil
-              end
-              if cbase == Type.any
-                klass = Type.any
+            if type == :class
+              if superclass.is_a?(Type::Class)
+                # okay
+              elsif superclass == Type.any
+                warn(ep, "superclass is any; Object is used instead")
+                superclass = Type::Builtin[:obj]
+              elsif superclass == Type.nil
+                superclass = Type::Builtin[:obj]
+              elsif superclass.is_a?(Type::Instance)
+                warn(ep, "superclass is an instance; Object is used instead")
+                superclass = Type::Builtin[:obj]
               else
-                klass = new_class(cbase, id, [], superclass, ep.ctx.iseq.absolute_path)
+                warn(ep, "superclass is not a class; Object is used instead")
+                superclass = Type::Builtin[:obj]
               end
+            else # module
+              superclass = nil
+            end
+            if cbase == Type.any
+              klass = Type.any
+            else
+              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
@@ -1271,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
@@ -1942,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,16 +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]
-      scratch.include_module(recv, arg, ep.ctx.iseq.absolute_path)
+      arg.each_child do |arg|
+        if arg.is_a?(Type::Class)
+          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.extend_module(recv, arg, ep.ctx.iseq.absolute_path)
+          scratch.include_module(recv, arg, nil, true, ep.ctx.iseq.absolute_path)
         end
       end
       ctn[recv, ep, env]
@@ -174,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
@@ -487,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)
 
@@ -497,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)