typeprof 0.14.1 → 0.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d5828bf5dda203756a758bba9809d3b1fe81b284cc1373f00ff75ca175afe998
-  data.tar.gz: c274d8bda556407a33c70227a4caea57f1ae91f79ee546f9076d6ffac01891a5
+  metadata.gz: dcefd3a4da176820246ad53757286aa1f7f8b2d21a6d1300763c91ba252e95ca
+  data.tar.gz: 1bf7429a4cf7d59e1ab4ca10f5f065a22b85adbbda922c67060d0ede64aab60f
 SHA512:
-  metadata.gz: e32f209894645a18b36a24c2347e86e249ffa0bcd2c93565d1920551ef143e73f6f3c58011250a545d761e9212aee032e99a44503e4dad5e1975d73de412d3c9
-  data.tar.gz: f3463cbae97beff6b359acb14a3a871f83d0ed37332e46ce38d846b2c486a9af3e6864a5450fe82e0abae79763b71ed55a26f1ab03d6a04aa9eb62232dd435fe
+  metadata.gz: ff14f14aa923ca807db9d7f1bc7f537c46e735bd194a0b59758dfdba0e04c04175ca0505fe6c00f739fec7933eeeab5010646891f56e14d5245f5b8613dd7d3b
+  data.tar.gz: 73a05bece353a7b4dbefba9f16e723fb088795e9f029b143721b03543e53ae19a8adb9908b3de41c839fbfb10a8d34c76ed0fa4f1b072801d7334233be63b1c9

data/Gemfile.lock

@@ -1,8 +1,8 @@
 PATH
   remote: .
   specs:
-    typeprof (0.14.1)
-      rbs (>= 1.2.0)
+    typeprof (0.15.0)
+      rbs (>= 1.3.1)
 
 GEM
   remote: https://rubygems.org/
@@ -11,7 +11,7 @@ GEM
     docile (1.4.0)
     power_assert (2.0.0)
     rake (13.0.1)
-    rbs (1.2.0)
+    rbs (1.3.1)
     simplecov (0.21.2)
       docile (~> 1.1)
       simplecov-html (~> 0.11)
@@ -19,7 +19,7 @@ GEM
     simplecov-html (0.12.3)
     simplecov_json_formatter (0.1.3)
     stackprof (0.2.17)
-    test-unit (3.4.1)
+    test-unit (3.4.2)
       power_assert
 
 PLATFORMS
@@ -36,4 +36,4 @@ DEPENDENCIES
   typeprof!
 
 BUNDLED WITH
-   2.3.0.dev
+   2.2.15

data/lib/typeprof/analyzer.rb

@@ -277,20 +277,22 @@ module TypeProf
       @pending_execution = {}
       @executed_iseqs = Utils::MutableSet.new
 
-      @loaded_features = {}
+      @loaded_files = {}
 
       @rbs_reader = RBSReader.new
 
       @terminated = false
 
       @anonymous_struct_gen_id = 0
+
+      @types_being_shown = []
     end
 
     def add_entrypoint(iseq)
       @entrypoints << iseq
     end
 
-    attr_reader :return_envs, :loaded_features, :rbs_reader
+    attr_reader :return_envs, :loaded_files, :rbs_reader
 
     def get_env(ep)
       @ep2env[ep]
@@ -329,9 +331,10 @@ module TypeProf
         @cvars = VarTable.new
         @absolute_path = absolute_path
         @namespace = nil
+        @subclasses = []
       end
 
-      attr_reader :kind, :modules, :consts, :methods, :ivars, :cvars, :absolute_path
+      attr_reader :kind, :modules, :consts, :methods, :ivars, :cvars, :absolute_path, :subclasses
       attr_accessor :name, :klass_obj
 
       def mix_module(kind, mod, type_args, singleton, absolute_path)
@@ -445,6 +448,7 @@ module TypeProf
       idx = @class_defs.size
       if superclass
         @class_defs[idx] = ClassDef.new(:class, show_name, absolute_path)
+        @class_defs[superclass.idx].subclasses << idx unless superclass == :__root__
         klass = Type::Class.new(:class, idx, type_params, superclass, show_name)
         @class_defs[idx].klass_obj = klass
         cbase ||= klass # for bootstrap
@@ -471,6 +475,7 @@ module TypeProf
       superclass = Type::Builtin[:struct]
       name = "AnonymousStruct_generated_#{ @anonymous_struct_gen_id += 1 }"
       @class_defs[idx] = ClassDef.new(:class, [name], ep.ctx.iseq.absolute_path)
+      #@class_defs[superclass.idx].subclasses << idx # needed?
       klass = Type::Class.new(:class, idx, [], superclass, name)
       add_superclass_type_args!(klass, [Type.any])
       @class_defs[idx].klass_obj = klass
@@ -526,6 +531,13 @@ module TypeProf
       end
     end
 
+    def traverse_subclasses(klass, &blk)
+      @class_defs[klass.idx].subclasses.each do |subclass|
+        yield @class_defs[subclass]
+        traverse_subclasses(@class_defs[subclass].klass_obj, &blk)
+      end
+    end
+
     def search_method(klass, singleton, mid, &blk)
       # XXX: support method alias correctly
       klass_orig = klass
@@ -545,7 +557,18 @@ module TypeProf
       end
     end
 
-    def get_method(klass, singleton, mid)
+    def get_method(klass, singleton, include_subclasses, mid)
+      if include_subclasses
+        subclasses_mthds = []
+        traverse_subclasses(klass) do |subclass|
+          subclass.search_method(singleton, mid, {}) do |mthds,|
+            subclasses_mthds.concat(mthds.to_a)
+          end
+        end
+        search_method(klass, singleton, mid) {|mthds,| return subclasses_mthds + mthds.to_a }
+        return subclasses_mthds
+      end
+
       search_method(klass, singleton, mid) {|mthds,| return mthds }
     end
 
@@ -646,9 +669,10 @@ module TypeProf
       if klass == Type.any
         self
       else
-        mdefs = get_method(klass, singleton, orig_mid)
+        mdefs = get_method(klass, singleton, false, orig_mid) # XXX: include_subclass == false??
         if mdefs
-          mdefs.each do |mdef|
+          # dup is needed for `alias foo foo` (otherwise, "can't add a new key into hash during iteration" error occurs)
+          mdefs.dup.each do |mdef|
             @class_defs[klass.idx].add_method(alias_mid, singleton, AliasMethodDef.new(orig_mid, mdef, ep))
           end
         end
@@ -755,24 +779,32 @@ module TypeProf
       end
     end
 
-    def get_ivar(recv)
+    def identify_class_for_ivar(recv, var)
+      klass, singleton = recv.method_dispatch_info
+      return nil unless klass
+      search_method(klass, singleton, var) do |mthds, klass0, singleton0|
+        if mthds.any? {|mthd| mthd.is_a?(AttrMethodDef) }
+          return klass0, singleton
+        end
+      end
+      return klass, singleton
+    end
+
+    def get_ivar(recv, var)
       recv = recv.base_type while recv.respond_to?(:base_type)
-      case recv
-      when Type::Class
-        [@class_defs[recv.idx], true]
-      when Type::Instance
-        [@class_defs[recv.klass.idx], false]
-      when Type::Any
-        return
+
+      klass, singleton = identify_class_for_ivar(recv, var.to_s[1..].to_sym) # search attr_reader
+
+      if klass
+        return @class_defs[klass.idx], singleton
       else
-        warn "???"
-        return
+        return nil
       end
     end
 
     def add_ivar_read!(recv, var, ep, &ctn)
       recv.each_child do |recv|
-        class_def, singleton = get_ivar(recv)
+        class_def, singleton = get_ivar(recv, var)
         next unless class_def
         class_def.ivars.add_read!([singleton, var], ep, &ctn)
       end
@@ -780,7 +812,7 @@ module TypeProf
 
     def add_ivar_write!(recv, var, ty, ep)
       recv.each_child do |recv|
-        class_def, singleton = get_ivar(recv)
+        class_def, singleton = get_ivar(recv, var)
         next unless class_def
         class_def.ivars.add_write!([singleton, var], ty, ep, self)
       end
@@ -901,7 +933,16 @@ module TypeProf
       prologue_env = Env.new(StaticEnv.new(Type.bot, Type.nil, false, true), [], [], Utils::HashWrapper.new({}))
 
       until @entrypoints.empty?
-        iseq = @entrypoints.shift
+        entrypoint = @entrypoints.shift
+        if entrypoint.is_a?(String)
+          file = entrypoint
+          next if @loaded_files[File.expand_path(file)]
+          iseq = ISeq.compile(file)
+        else
+          iseq = entrypoint
+        end
+
+        @loaded_files[iseq.absolute_path] = true
         ep, env = TypeProf.starting_state(iseq)
         merge_env(ep, env)
         add_callsite!(ep.ctx, prologue_ep, prologue_env) {|ty, ep| }
@@ -1316,12 +1357,10 @@ module TypeProf
       when :send
         env, recvs, mid, aargs = setup_actual_arguments(:method, operands, ep, env)
         recvs = Type.any if recvs == Type.bot
-        recvs.each_child do |recv|
-          do_send(recv, mid, aargs, ep, env) 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
+        do_send(recvs, mid, aargs, ep, env) 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
         return
       when :recv_getlocal_send_branch
@@ -1389,24 +1428,22 @@ module TypeProf
         send_operands, branch_operands = operands
         env, recvs, mid, aargs = setup_actual_arguments(:method, send_operands, ep, env)
         recvs = Type.any if recvs == Type.bot
-        recvs.each_child do |recv|
-          do_send(recv, mid, aargs, ep, env) do |ret_ty, ep, env|
-            env, ret_ty, = localize_type(ret_ty, env, ep)
+        do_send(recvs, mid, aargs, ep, env) do |ret_ty, ep, env|
+          env, ret_ty, = localize_type(ret_ty, env, ep)
 
-            branchtype, target, = branch_operands
-            # branchtype: :if or :unless or :nil
-            ep_then = ep.next
-            ep_else = ep.jump(target)
+          branchtype, target, = branch_operands
+          # branchtype: :if or :unless or :nil
+          ep_then = ep.next
+          ep_else = ep.jump(target)
 
-            case ret_ty
-            when Type::Instance.new(Type::Builtin[:true])
-              merge_env(branchtype == :if ? ep_else : ep_then, env)
-            when Type::Instance.new(Type::Builtin[:false])
-              merge_env(branchtype == :if ? ep_then : ep_else, env)
-            else
-              merge_env(ep_then, env)
-              merge_env(ep_else, env)
-            end
+          case ret_ty
+          when Type::Instance.new(Type::Builtin[:true])
+            merge_env(branchtype == :if ? ep_else : ep_then, env)
+          when Type::Instance.new(Type::Builtin[:false])
+            merge_env(branchtype == :if ? ep_then : ep_else, env)
+          else
+            merge_env(ep_then, env)
+            merge_env(ep_else, env)
           end
         end
         return
@@ -1440,12 +1477,10 @@ module TypeProf
               # 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
+              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
@@ -2133,30 +2168,32 @@ module TypeProf
       return env, recv, mid, aargs
     end
 
-    def do_send(recv, mid, aargs, ep, env, &ctn)
-      case recv
-      when Type::Void
-        error(ep, "void's method is called: #{ globalize_type(recv, env, ep).screen_name(self) }##{ mid }")
-        ctn[Type.any, ep, env]
-      when Type::Any
-        ctn[Type.any, ep, env]
-      else
-        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)
-          end
+    def do_send(recvs, mid, aargs, ep, env, &ctn)
+      recvs.each_child do |recv|
+        case recv
+        when Type::Void
+          error(ep, "void's method is called: #{ globalize_type(recv, env, ep).screen_name(self) }##{ mid }")
+          ctn[Type.any, ep, env]
+        when Type::Any
+          ctn[Type.any, ep, env]
         else
-          meths = get_method(klass, singleton, :method_missing) if klass
+          klass, singleton, include_subclasses = recv.method_dispatch_info
+          meths = get_method(klass, singleton, include_subclasses, mid) if klass
           if meths
-            aargs = aargs.for_method_missing(Type::Symbol.new(mid, Type::Instance.new(Type::Builtin[:sym])))
             meths.each do |meth|
-              meth.do_send(recv, :method_missing, aargs, ep, env, self, &ctn)
+              meth.do_send(recv, mid, aargs, ep, env, self, &ctn)
             end
           else
-            error(ep, "undefined method: #{ globalize_type(recv, env, ep).screen_name(self) }##{ mid }")
-            ctn[Type.any, ep, env]
+            meths = get_method(klass, singleton, include_subclasses, :method_missing) if klass
+            if meths
+              aargs = aargs.for_method_missing(Type::Symbol.new(mid, Type::Instance.new(Type::Builtin[:sym])))
+              meths.each do |meth|
+                meth.do_send(recv, :method_missing, aargs, ep, env, self, &ctn)
+              end
+            else
+              error(ep, "undefined method: #{ globalize_type(recv, env, ep).screen_name(self) }##{ mid }")
+              ctn[Type.any, ep, env]
+            end
           end
         end
       end
@@ -2241,7 +2278,11 @@ module TypeProf
           next unless @block_to_ctx[blk.block_body] # this occurs when screen_name is called before type-profiling finished (e.g., error message)
           @block_to_ctx[blk.block_body].each do |blk_ctx|
             if farg_tys
-              farg_tys = farg_tys.merge_as_block_arguments(@method_signatures[blk_ctx])
+              if @method_signatures[blk_ctx]
+                farg_tys = farg_tys.merge_as_block_arguments(@method_signatures[blk_ctx])
+              else
+                # this occurs when screen_name is called before type-profiling finished (e.g., error message)
+              end
             else
               farg_tys = @method_signatures[blk_ctx]
             end
@@ -2251,17 +2292,24 @@ module TypeProf
         end
       end
 
-      farg_tys = farg_tys ? farg_tys.screen_name(nil, self) : "(unknown)"
-      ret_ty = ret_ty.screen_name(self)
-      ret_ty = (ret_ty.include?("|") ? "(#{ ret_ty })" : ret_ty) # XXX?
+      return Type.any.screen_name(self) if @types_being_shown.include?(farg_tys) || @types_being_shown.include?(ret_ty)
+
+      begin
+        @types_being_shown << farg_tys << ret_ty
+        farg_tys = farg_tys ? farg_tys.screen_name(nil, self) : "(unknown)"
+        ret_ty = ret_ty.screen_name(self)
+        ret_ty = (ret_ty.include?("|") ? "(#{ ret_ty })" : ret_ty) # XXX?
 
-      farg_tys = farg_tys + " " if farg_tys != ""
-      "^#{ farg_tys }-> #{ ret_ty }"
+        farg_tys = farg_tys + " " if farg_tys != ""
+        "^#{ farg_tys }-> #{ ret_ty }"
+      ensure
+        @types_being_shown.pop(2)
+      end
     end
 
     def show_method_signature(ctx)
       farg_tys = @method_signatures[ctx]
-      ret_ty = @return_values[ctx] || Type.bot
+      ret_ty = ctx.mid == :initialize ? Type::Void.new : @return_values[ctx] || Type.bot
 
       untyped = farg_tys.include_untyped?(self) || ret_ty.include_untyped?(self)
 

data/lib/typeprof/builtin.rb

@@ -73,9 +73,9 @@ module TypeProf
       else
         ty = Type::Instance.new(recv)
       end
-      meths = scratch.get_method(recv, false, :initialize)
+      meths = scratch.get_method(recv, false, false, :initialize)
       meths.flat_map do |meth|
-        meth.do_send(ty, :initialize, aargs, ep, env, scratch) do |ret_ty, ep, env|
+        meth.do_send(ty, :initialize, aargs, ep, env, scratch) do |_ret_ty, ep, env|
           ctn[ty, ep, env]
         end
       end
@@ -104,7 +104,7 @@ module TypeProf
         sym = get_sym("respond_to?", aargs.lead_tys[0], ep, scratch)
         if sym
           klass, singleton = recv.method_dispatch_info
-          if scratch.get_method(klass, singleton, sym)
+          if scratch.get_method(klass, singleton, false, sym)
             true_val = Type::Instance.new(Type::Builtin[:true])
             ctn[true_val, ep, env]
           else
@@ -334,7 +334,7 @@ module TypeProf
       else
         aargs.lead_tys.each do |aarg|
           sym = get_sym("module_function", aarg, ep, scratch) or next
-          meths = scratch.get_method(recv, false, sym)
+          meths = scratch.get_method(recv, false, false, sym)
           meths.each do |mdef|
             scratch.add_method(recv, sym, true, mdef)
           end
@@ -350,7 +350,7 @@ module TypeProf
         if recv.is_a?(Type::Class)
           aargs.lead_tys.each do |aarg|
             sym = get_sym("public", aarg, ep, scratch) or next
-            meths = scratch.get_method(recv, false, sym)
+            meths = scratch.get_method(recv, false, false, sym)
             next unless meths
             meths.each do |mdef|
               mdef.pub_meth = true if mdef.respond_to?(:pub_meth=)
@@ -370,7 +370,7 @@ module TypeProf
         if recv.is_a?(Type::Class)
           aargs.lead_tys.each do |aarg|
             sym = get_sym("private", aarg, ep, scratch) or next
-            meths = scratch.get_method(recv, false, sym)
+            meths = scratch.get_method(recv, false, false, sym)
             next unless meths
             meths.each do |mdef|
               mdef.pub_meth = false if mdef.respond_to?(:pub_meth=)
@@ -635,9 +635,6 @@ module TypeProf
     end
 
     def self.file_require(feature, scratch)
-      return :done, :false if scratch.loaded_features[feature]
-      scratch.loaded_features[feature] = true
-
       # XXX: dynamic RBS load is really needed??  Another idea:
       #
       # * RBS should be loaded in advance of analysis
@@ -653,7 +650,11 @@ module TypeProf
 
       begin
         filetype, path = $LOAD_PATH.resolve_feature_path(feature)
+
         if filetype == :rb
+          return :done, :false if scratch.loaded_files[path]
+          scratch.loaded_files[path] = true
+
           return :do, path if File.readable?(path)
 
           return :error, "failed to load: #{ path }"
@@ -714,13 +715,14 @@ module TypeProf
           return ctn[Type.any, ep, env]
         end
 
-        if scratch.loaded_features[feature]
+        path = File.join(File.dirname(ep.ctx.iseq.absolute_path), feature) + ".rb" # XXX
+
+        if scratch.loaded_files[path]
           result = Type::Instance.new(Type::Builtin[:false])
           return ctn[result, ep, env]
         end
-        scratch.loaded_features[feature] = true
+        scratch.loaded_files[path] = true
 
-        path = File.join(File.dirname(ep.ctx.iseq.path), feature) + ".rb" # XXX
         return Builtin.file_load(path, ep, env, scratch, &ctn) if File.readable?(path)
 
         scratch.warn(ep, "failed to load: #{ path }")

data/lib/typeprof/cli.rb

@@ -64,6 +64,7 @@ module TypeProf
       opt.separator "Advanced options:"
       opt.on("--[no-]stub-execution", "Force to call all unreachable methods with \"untyped\" arguments") {|v| options[:stub_execution] = v }
       opt.on("--type-depth-limit DEPTH", Integer, "Limit the maximum depth of nested types") {|v| options[:type_depth_limit] = v }
+      opt.on("--union-width-limit WIDTH", Integer, "Limit the maximum count of class instances in one union type") {|v| options[:union_width_limit] = v }
       opt.on("--debug", "Display analysis log (for debugging purpose)") { verbose = 2 }
       opt.on("--[no-]stackprof MODE", /\Acpu|wall|object\z/, "Enable stackprof (for debugging purpose)") {|v| options[:stackprof] = v.to_sym }
 

data/lib/typeprof/config.rb

@@ -40,6 +40,7 @@ module TypeProf
         show_source_locations: false,
         stub_execution: true,
         type_depth_limit: 5,
+        union_width_limit: 10,
         stackprof: nil,
       }.merge(opt[:options])
       super(**opt)
@@ -98,7 +99,7 @@ module TypeProf
       if rb.is_a?(Array) # [String name, String content]
         iseq = ISeq.compile_str(*rb.reverse)
       else
-        iseq = ISeq.compile(rb)
+        iseq = rb
       end
       scratch.add_entrypoint(iseq)
     end

data/lib/typeprof/export.rb

@@ -149,6 +149,7 @@ module TypeProf
             source_locations[key] ||= ctx.iseq.source_location(0)
             (methods[key] ||= []) << @scratch.show_method_signature(ctx)
           when AliasMethodDef
+            next if mdef.def_ep && Config.check_dir_filter(mdef.def_ep.source_location) == :exclude
             alias_name, orig_name = mid, mdef.orig_mid
             if singleton
               alias_name = "self.#{ alias_name }"

data/lib/typeprof/import.rb

@@ -373,25 +373,30 @@ module TypeProf
     end
 
     def conv_block(rbs_block)
-      type = rbs_block.type
+      blk = rbs_block.type
 
-      # XXX
-      raise NotImplementedError unless type.optional_keywords.empty?
-      raise NotImplementedError unless type.required_keywords.empty?
-      raise NotImplementedError if type.rest_keywords
-
-      req = rbs_block.required
-
-      lead_tys = type.required_positionals.map do |type|
-        conv_type(type.type)
-      end
-      opt_tys = type.optional_positionals.map do |type|
-        conv_type(type.type)
-      end
+      lead_tys = blk.required_positionals.map {|type| conv_type(type.type) }
+      opt_tys = blk.optional_positionals.map {|type| conv_type(type.type) }
+      rest_ty = blk.rest_positionals
+      rest_ty = conv_type(rest_ty.type) if rest_ty
+      opt_kw_tys = blk.optional_keywords.to_h {|key, type| [key, conv_type(type.type)] }
+      req_kw_tys = blk.required_keywords.to_h {|key, type| [key, conv_type(type.type)] }
+      rest_kw_ty = blk.rest_keywords
+      rest_kw_ty = conv_type(rest_kw_ty.type) if rest_kw_ty
 
-      ret_ty = conv_type(type.return_type)
+      ret_ty = conv_type(blk.return_type)
 
-      [req, lead_tys, opt_tys, ret_ty]
+      {
+        required_block: rbs_block.required,
+        lead_tys: lead_tys,
+        opt_tys: opt_tys,
+        rest_ty: rest_ty,
+        req_kw_tys: req_kw_tys,
+        opt_kw_tys: opt_kw_tys,
+        rest_kw_ty: rest_kw_ty,
+        blk: blk,
+        ret_ty: ret_ty,
+      }
     end
 
     def conv_type(ty)
@@ -630,7 +635,13 @@ module TypeProf
       kw_tys = []
       req_kw_tys.each {|key, ty| kw_tys << [true, key, conv_type(ty)] }
       opt_kw_tys.each {|key, ty| kw_tys << [false, key, conv_type(ty)] }
-      kw_rest_ty = conv_type(rest_kw_ty) if rest_kw_ty
+      if rest_kw_ty
+        ty = conv_type(rest_kw_ty)
+        kw_rest_ty = Type.gen_hash do |h|
+          k_ty = Type::Instance.new(Type::Builtin[:sym])
+          h[k_ty] = ty
+        end
+      end
 
       blks = conv_block(blk)
 
@@ -643,13 +654,36 @@ module TypeProf
 
     def conv_block(blk)
       return [Type.nil] unless blk
-      req, lead_tys, opt_tys, ret_ty = blk
+
+      required_block = blk[:required_block]
+      lead_tys = blk[:lead_tys]
+      opt_tys = blk[:opt_tys]
+      rest_ty = blk[:rest_ty]
+      req_kw_tys = blk[:req_kw_tys]
+      opt_kw_tys = blk[:opt_kw_tys]
+      rest_kw_ty = blk[:rest_kw_ty]
+      ret_ty = blk[:ret_ty]
+
       lead_tys = lead_tys.map {|ty| conv_type(ty) }
       opt_tys = opt_tys.map {|ty| conv_type(ty) }
-      msig = MethodSignature.new(lead_tys, opt_tys, nil, [], {}, nil, Type.nil)
+      rest_ty = conv_type(rest_ty) if rest_ty
+      kw_tys = []
+      req_kw_tys.each {|key, ty| kw_tys << [true, key, conv_type(ty)] }
+      opt_kw_tys.each {|key, ty| kw_tys << [false, key, conv_type(ty)] }
+      if rest_kw_ty
+        ty = conv_type(rest_kw_ty)
+        kw_rest_ty = Type.gen_hash do |h|
+          k_ty = Type::Instance.new(Type::Builtin[:sym])
+          h[k_ty] = ty
+        end
+      end
+
+      msig = MethodSignature.new(lead_tys, opt_tys, rest_ty, [], kw_tys, kw_rest_ty, Type.nil)
+
       ret_ty = conv_type(ret_ty)
+
       ret = [Type::Proc.new(TypedBlock.new(msig, ret_ty), Type::Builtin[:proc])]
-      ret << Type.nil unless req
+      ret << Type.nil unless required_block
       ret
     end
 
@@ -694,7 +728,7 @@ module TypeProf
         end
       when :union
         tys = ty[1]
-        Type::Union.new(Utils::Set[*tys.map {|ty2| conv_type(ty2) }], nil).normalize # XXX: Array and Hash support
+        Type::Union.create(Utils::Set[*tys.map {|ty2| conv_type(ty2) }], nil) # XXX: Array and Hash support
       when :var
         Type::Var.new(ty[1])
       when :proc

data/lib/typeprof/type.rb

@@ -102,34 +102,43 @@ module TypeProf
 
       ty1, ty2 = self, other
 
-      ty1 = container_to_union(ty1)
-      ty2 = container_to_union(ty2)
+      case
+      when ty1.is_a?(Union)
+        ty1_types = ty1.types
+        ty1_elems = ty1.elems
+      when ty1.is_a?(Array) || ty1.is_a?(Hash)
+        ty1_types = Utils::Set[]
+        ty1_elems = {[ty1.class, ty1.base_type] => ty1.elems}
+      else
+        ty1_types = ty1_elems = nil
+      end
+
+      case
+      when ty2.is_a?(Union)
+        ty2_types = ty2.types
+        ty2_elems = ty2.elems
+      when ty2.is_a?(Array) || ty2.is_a?(Hash)
+        ty2_types = Utils::Set[]
+        ty2_elems = {[ty2.class, ty2.base_type] => ty2.elems}
+      else
+        ty2_types = ty2_elems = nil
+      end
 
-      if ty1.is_a?(Union) && ty2.is_a?(Union)
-        ty = ty1.types.sum(ty2.types)
-        all_elems = ty1.elems.dup || {}
-        ty2.elems&.each do |key, elems|
+      if ty1_types && ty2_types
+        ty = ty1_types.sum(ty2_types)
+        all_elems = ty1_elems.dup || {}
+        ty2_elems&.each do |key, elems|
           all_elems[key] = union_elems(all_elems[key], elems)
         end
         all_elems = nil if all_elems.empty?
 
-        Type::Union.new(ty, all_elems).normalize
-      else
-        ty1, ty2 = ty2, ty1 if ty2.is_a?(Union)
-        if ty1.is_a?(Union)
-          Type::Union.new(ty1.types.add(ty2), ty1.elems).normalize
-        else
-          Type::Union.new(Utils::Set[ty1, ty2], nil).normalize
-        end
-      end
-    end
-
-    private def container_to_union(ty)
-      case ty
-      when Type::Array, Type::Hash
-        Type::Union.new(Utils::Set[], { [ty.class, ty.base_type] => ty.elems })
+        Type::Union.create(ty, all_elems)
+      elsif ty1_types
+        Type::Union.create(ty1_types.add(ty2), ty1_elems)
+      elsif ty2_types
+        Type::Union.create(ty2_types.add(ty1), ty2_elems)
       else
-        ty
+        Type::Union.create(Utils::Set[ty1, ty2], nil)
       end
     end
 
@@ -207,6 +216,37 @@ module TypeProf
 
 
     class Union < Type
+      def self.create(tys, elems)
+        if tys.size == 1 && !elems
+          tys.each {|ty| return ty }
+        elsif tys.size == 0
+          if elems && elems.size == 1
+            (container_kind, base_type), nelems = elems.first
+            # container_kind = Type::Array or Type::Hash
+            container_kind.new(nelems, base_type)
+          else
+            new(tys, elems)
+          end
+        else
+          class_instances = []
+          non_class_instances = []
+          degenerated = false
+          tys.each do |ty|
+            if ty != Type::Instance.new(Type::Builtin[:nil]) && ty.is_a?(Type::Instance) && ty.klass.kind == :class
+              class_instances << ty
+              degenerated = true if ty.include_subclasses
+            else
+              non_class_instances << ty
+            end
+          end
+          if (Config.options[:union_width_limit] >= 2 && class_instances.size >= Config.options[:union_width_limit]) || (degenerated && class_instances.size >= 2)
+            create(Utils::Set[Instance.new_degenerate(class_instances), *non_class_instances], elems)
+          else
+            new(tys, elems)
+          end
+        end
+      end
+
       def initialize(tys, elems)
         raise unless tys.is_a?(Utils::Set)
         @types = tys # Set
@@ -243,22 +283,6 @@ module TypeProf
 
       attr_reader :types, :elems
 
-      def normalize
-        if @types.size == 1 && !@elems
-          @types.each {|ty| return ty }
-        elsif @types.size == 0
-          if @elems && @elems.size == 1
-            (container_kind, base_type), elems = @elems.first
-            # container_kind = Type::Array or Type::Hash
-            container_kind.new(elems, base_type)
-          else
-            self
-          end
-        else
-          self
-        end
-      end
-
       def each_child(&blk) # local
         @types.each(&blk)
         raise if @elems
@@ -343,7 +367,7 @@ module TypeProf
         end
         elems = nil if elems.empty?
 
-        Type::Union.new(tys, elems).normalize
+        Type::Union.create(tys, elems)
       end
 
       def localize(env, alloc_site, depth)
@@ -357,7 +381,7 @@ module TypeProf
           env, ty = ty.localize(env, alloc_site, depth - 1)
           tys = tys.add(ty)
         end
-        ty = Union.new(tys, nil).normalize
+        ty = Union.create(tys, nil)
         return env, ty
       end
 
@@ -381,7 +405,7 @@ module TypeProf
         elems = @elems&.to_h do |(container_kind, base_type), elems|
           [[container_kind, base_type], elems.substitute(subst, depth - 1)]
         end
-        ty = Union.new(tys, elems).normalize
+        ty = Union.create(tys, elems)
         unions.each do |ty0|
           ty = ty.union(ty0)
         end
@@ -484,7 +508,7 @@ module TypeProf
       end
 
       def method_dispatch_info
-        [self, true]
+        [self, true, false]
       end
 
       def consistent?(other)
@@ -513,15 +537,40 @@ module TypeProf
     end
 
     class Instance < Type
-      def initialize(klass)
+      def initialize(klass, include_subclasses=false)
         raise unless klass
         raise if klass == Type.any
         raise if klass.is_a?(Type::Instance)
         raise if klass.is_a?(Type::Union)
         @klass = klass
+        @include_subclasses = include_subclasses
+      end
+
+      def self.new_degenerate(instances)
+        klass = instances.first.klass
+        ancestors = []
+        ancestor_idxs = {}
+        while klass != :__root__
+          ancestor_idxs[klass] = ancestors.size
+          ancestors << klass
+          klass = klass.superclass
+        end
+        common_superclass = nil
+        instances[1..].each do |instance|
+          klass = instance.klass
+          while !ancestor_idxs[klass]
+            klass = klass.superclass
+          end
+          common_superclass = klass
+          ancestor_idxs[klass].times do |i|
+            ancestor_idxs.delete(ancestors[i])
+            ancestors[i] = nil
+          end
+        end
+        new(common_superclass, true)
       end
 
-      attr_reader :klass
+      attr_reader :klass, :include_subclasses
 
       def inspect
         "I[#{ @klass.inspect }]"
@@ -533,12 +582,12 @@ module TypeProf
         when Type::Builtin[:true] then "true"
         when Type::Builtin[:false] then "false"
         else
-          scratch.get_class_name(@klass)
+          scratch.get_class_name(@klass) + (@include_subclasses ? "" : "")
         end
       end
 
       def method_dispatch_info
-        [@klass, false]
+        [@klass, false, @include_subclasses]
       end
 
       def consistent?(other)
@@ -847,6 +896,7 @@ module TypeProf
       end
       if Config.options[:show_parameter_names]
         farg_names = farg_names.map {|name| name == :type ? :type_ : name } # XXX: workaround of RBS parser bug
+        farg_names = farg_names.map {|name| name.is_a?(Integer) ? "noname_#{ name }" : name }
         fargs = fargs.zip(farg_names).map {|farg, name| name ? "#{ farg } #{ name }" : farg }
       end
       fargs = fargs.empty? ? "" : "(#{ fargs.join(", ") })"

data/lib/typeprof/version.rb

@@ -1,3 +1,3 @@
 module TypeProf
-  VERSION = "0.14.1"
+  VERSION = "0.15.0"
 end

data/smoke/alias2.rb

@@ -17,5 +17,5 @@ class Foo
   @c: :z
 
   alias self.[] self.new
-  def initialize: (:x a, :y b, :z c) -> [:x, :y, :z]
+  def initialize: (:x a, :y b, :z c) -> void
 end

data/smoke/array3.rb

@@ -20,7 +20,7 @@ __END__
 class Foo
   @ary: [Integer, String?, :sym]
 
-  def initialize: -> [Integer, String, :sym]
+  def initialize: -> void
   def foo: -> String?
   def bar: -> nil
 end

data/smoke/attr-module.rb

@@ -10,18 +10,15 @@ end
 Foo.foo = 42
 Bar.new.foo = "str"
 
-# XXX: the output may be improved
-
 __END__
 # Classes
 module Foo
   self.@foo: Integer
 
-  attr_accessor foo: untyped
+  attr_accessor foo: String
   attr_accessor self.foo: Integer
 end
 
 class Bar
   include Foo
-  @foo: String
 end

data/smoke/attr-vis.rb

@@ -30,7 +30,7 @@ smoke/attr-vis.rb:20: [warning] inconsistent assignment to RBS-declared variable
 
 # Classes
 class Foo
-  def initialize: -> Integer
+  def initialize: -> void
 
   private
   attr_accessor foo: Integer | String

data/smoke/attr.rb

@@ -20,7 +20,7 @@ foo.c = :ccc
 __END__
 # Classes
 class Foo
-  def initialize: (:aaa a) -> :aaa
+  def initialize: (:aaa a) -> void
   attr_reader a: :aaa
   attr_writer b: :bbb
   def get_b: -> :bbb

data/smoke/huge_union.rb

@@ -0,0 +1,86 @@
+class C0; end
+class C1 < C0; def foo(n); end; end
+class C2 < C0; def foo(n); end; end
+class C3 < C0; def foo(n); end; end
+class C4 < C0; def foo(n); end; end
+class C5 < C0; def foo(n); end; end
+class C6 < C0; def foo(n); end; end
+class C7 < C0; def foo(n); end; end
+class C8 < C0; def foo(n); end; end
+class C9 < C0; def foo(n); end; end
+class C10 < C0; def foo(n); end; end
+class C11 < C0; def foo(n); end; end
+class C12 < C0; def foo(n); end; end
+
+def dispatch_foo(n)
+  n.foo("str")
+end
+
+dispatch_foo(C1.new)
+dispatch_foo(C2.new)
+dispatch_foo(C3.new)
+dispatch_foo(C4.new)
+dispatch_foo(C5.new)
+dispatch_foo(C6.new)
+dispatch_foo(C7.new)
+dispatch_foo(C8.new)
+dispatch_foo(C9.new)
+dispatch_foo(C10.new)
+
+__END__
+# Classes
+class Object
+  private
+  def dispatch_foo: (C0 n) -> nil
+end
+
+class C0
+end
+
+class C1 < C0
+  def foo: (String n) -> nil
+end
+
+class C2 < C0
+  def foo: (String n) -> nil
+end
+
+class C3 < C0
+  def foo: (String n) -> nil
+end
+
+class C4 < C0
+  def foo: (String n) -> nil
+end
+
+class C5 < C0
+  def foo: (String n) -> nil
+end
+
+class C6 < C0
+  def foo: (String n) -> nil
+end
+
+class C7 < C0
+  def foo: (String n) -> nil
+end
+
+class C8 < C0
+  def foo: (String n) -> nil
+end
+
+class C9 < C0
+  def foo: (String n) -> nil
+end
+
+class C10 < C0
+  def foo: (String n) -> nil
+end
+
+class C11 < C0
+  def foo: (String n) -> nil
+end
+
+class C12 < C0
+  def foo: (String n) -> nil
+end

data/smoke/initialize.rb

@@ -24,5 +24,5 @@ class A
   @str: String
   @val: (Integer | String)?
 
-  def initialize: ((Integer | String)? x) -> ((Integer | String)?)
+  def initialize: ((Integer | String)? x) -> void
 end

data/smoke/ivar2.rb

@@ -23,7 +23,7 @@ Foo.new.set
 __END__
 # Classes
 class Foo
-  def initialize: -> Hash[bot, bot]
+  def initialize: -> void
   def set: -> :sym
   attr_reader array: Array[:sym | Integer | String]
   attr_reader hash: {a: Integer, b: String, c: :sym}

data/smoke/ivar3.rb

@@ -13,5 +13,5 @@ smoke/ivar3.rb:3: [warning] inconsistent assignment to RBS-declared variable
 class Foo
   @bar: String
 
-  def initialize: -> String
+  def initialize: -> void
 end

data/smoke/kwrest.rb

@@ -1,6 +1,6 @@
 class Foo
   def foo(**r)
-    @r = r[42]
+    @r = r["foo".to_sym][42]
   end
 end
 
@@ -9,5 +9,5 @@ __END__
 class Foo
   @r: Integer
 
-# def foo: (**Hash[Integer, Integer]) -> void
+# def foo: (**Integer) -> void
 end

data/smoke/kwrest.rbs

@@ -1,3 +1,3 @@
 class Foo
-  def foo: (**Hash[Integer, Integer]) -> void
+  def foo: (**Integer) -> void
 end

data/smoke/method_missing.rb

@@ -24,6 +24,6 @@ end
 class C
   @target: D
 
-  def initialize: (D x) -> D
+  def initialize: (D x) -> void
   def method_missing: (:foo m, *:X | :Y | :Z args) -> nil
 end

data/smoke/noname.rb

@@ -0,0 +1,9 @@
+def foo(*)
+end
+
+__END__
+# Classes
+class Object
+  private
+  def foo: (*untyped noname_2) -> nil
+end

data/smoke/proc6.rb

@@ -0,0 +1,13 @@
+# a test for a recursive proc that receives (or returns) itself
+def foo
+  f = -> x { x }
+  f[f]
+  f
+end
+
+__END__
+# Classes
+class Object
+  private
+  def foo: -> ^(untyped) -> untyped
+end

data/smoke/proc7.rb

@@ -0,0 +1,32 @@
+class Foo
+  def id(&blk)
+    blk
+  end
+
+  def check(v)
+    rand < 0.5 ? v : [v]
+  end
+
+  def foo
+    check(id {}).call # cause "undefined method: [^-> nil?]#call"
+  end
+
+  def foo1
+    id { }
+  end
+end
+
+__END__
+# Errors
+smoke/proc7.rb:11: [error] undefined method: nil#call
+smoke/proc7.rb:11: [error] undefined method: [(^(unknown) -> bot | untyped)?]#call
+smoke/proc7.rb:11: [error] undefined method: nil#call
+smoke/proc7.rb:11: [error] undefined method: [(^-> nil | untyped)?]#call
+
+# Classes
+class Foo
+  def id: ?{ -> nil } -> ^-> nil?
+  def check: ((^-> nil | untyped)? v) -> (([(^-> nil | untyped)?] | ^-> nil | untyped)?)
+  def foo: -> untyped?
+  def foo1: -> ^-> nil?
+end

data/smoke/rbs-tyvar4.rb

@@ -32,6 +32,6 @@ __END__
 class Foo
   @ivar: Array[Array[String]]
 
-  def initialize: (Array[Array[String]] ivar) -> Array[Array[String]]
+  def initialize: (Array[Array[String]] ivar) -> void
   def foo: (:a | :b n) -> nil
 end

data/smoke/require1.rb

@@ -0,0 +1,13 @@
+require_relative "require2"
+
+class Foo
+  def foo
+  end
+end
+
+__END__
+# Classes
+class Foo
+  def bar: -> nil
+  def foo: -> nil
+end

data/smoke/require2.rb

@@ -0,0 +1,13 @@
+require_relative "require1"
+
+class Foo
+  def bar
+  end
+end
+
+__END__
+# Classes
+class Foo
+  def foo: -> nil
+  def bar: -> nil
+end

data/smoke/struct5.rb

@@ -12,5 +12,5 @@ __END__
 # Classes
 class Foo < Struct[untyped]
   attr_accessor foo(): String
-  def initialize: (Integer foo) -> Foo
+  def initialize: (Integer foo) -> void
 end

data/smoke/struct6.rb

@@ -11,5 +11,5 @@ class AnonymousStruct_generated_1 < Struct[untyped]
 end
 
 class Foo < AnonymousStruct_generated_1
-  def initialize: (untyped foo) -> Foo
+  def initialize: (untyped foo) -> void
 end

data/smoke/struct7.rb

@@ -13,5 +13,5 @@ end
 __END__
 # Classes
 class Foo < Struct[untyped]
-  def initialize: -> Foo
+  def initialize: -> void
 end

data/smoke/super3.rb

@@ -16,5 +16,5 @@ class Foo
   @a: Integer
 
   def self.new: (Integer a) -> Foo
-  def initialize: (Integer a) -> Integer
+  def initialize: (Integer a) -> void
 end

data/smoke/symbol-proc-attr.rb

@@ -18,5 +18,5 @@ end
 
 class Foo
   attr_reader foo: Integer | untyped
-  def initialize: (Integer | untyped foo) -> (Integer | untyped)
+  def initialize: (Integer | untyped foo) -> void
 end

data/smoke/symbol-proc-attr2.rb

@@ -11,5 +11,5 @@ __END__
 # Classes
 class Foo
   attr_reader foo: [Integer]
-  def initialize: -> [Integer]
+  def initialize: -> void
 end

data/typeprof.gemspec

@@ -30,5 +30,5 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_runtime_dependency "rbs", ">= 1.2.0"
+  spec.add_runtime_dependency "rbs", ">= 1.3.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: typeprof
 version: !ruby/object:Gem::Version
-  version: 0.14.1
+  version: 0.15.0
 platform: ruby
 authors:
 - Yusuke Endoh
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-05-18 00:00:00.000000000 Z
+date: 2021-07-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rbs
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.2.0
+        version: 1.3.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.2.0
+        version: 1.3.1
 description: |
   TypeProf performs a type analysis of non-annotated Ruby code.
 
@@ -216,6 +216,7 @@ files:
 - smoke/hash3.rb
 - smoke/hash4.rb
 - smoke/hash5.rb
+- smoke/huge_union.rb
 - smoke/included.rb
 - smoke/inheritance.rb
 - smoke/inheritance2.rb
@@ -267,6 +268,7 @@ files:
 - smoke/multiple-superclass.rb
 - smoke/next1.rb
 - smoke/next2.rb
+- smoke/noname.rb
 - smoke/object-send1.rb
 - smoke/object-send2.rb
 - smoke/object-send3.rb
@@ -290,6 +292,8 @@ files:
 - smoke/proc3.rb
 - smoke/proc4.rb
 - smoke/proc5.rb
+- smoke/proc6.rb
+- smoke/proc7.rb
 - smoke/public.rb
 - smoke/range.rb
 - smoke/rbs-alias.rb
@@ -332,6 +336,8 @@ files:
 - smoke/redo1.rb
 - smoke/redo2.rb
 - smoke/req-keyword.rb
+- smoke/require1.rb
+- smoke/require2.rb
 - smoke/rescue1.rb
 - smoke/rescue2.rb
 - smoke/rescue3.rb