typeprof 0.5.3 → 0.8.0

data/lib/typeprof/arguments.rb

@@ -10,6 +10,10 @@ module TypeProf
       raise unless blk_ty
     end
 
+    def for_method_missing(mid)
+      ActualArguments.new([mid] + @lead_tys, @rest_ty, @kw_tys, @blk_ty)
+    end
+
     attr_reader :lead_tys, :rest_ty, :kw_tys, :blk_ty
 
     def globalize(caller_env, visited, depth)
@@ -148,12 +152,14 @@ module TypeProf
               lead_tys = ty.elems.lead_tys
               rest_ty = ty.elems.rest_ty
             when Type::Union
-              other_elems = nil
-              ty.elems&.each do |(container_kind, base_type), elems|
-                if container_kind == Type::Array
-                  rest_ty = rest_ty ? rest_ty.union(elems.squash) : elems.squash
-                else
-                  other_elems = other_elems ? other_elems.union(elems) : elems
+              if ty.elems
+                other_elems = {}
+                ty.elems.each do |(container_kind, base_type), elems|
+                  if container_kind == Type::Array
+                    rest_ty = rest_ty ? rest_ty.union(elems.squash) : elems.squash
+                  else
+                    other_elems[[container_kind, base_type]] = elems
+                  end
                 end
               end
               lead_tys = [Type::Union.new(ty.types, other_elems)]

data/lib/typeprof/builtin.rb

@@ -33,10 +33,10 @@ module TypeProf
       h2 = aargs.lead_tys[1]
       elems = nil
       h1.each_child do |h1|
-        if h1.is_a?(Type::LocalHash)
+        if h1.is_a?(Type::Local) && h1.kind == Type::Hash
           h1_elems = scratch.get_container_elem_types(env, ep, h1.id)
           h2.each_child do |h2|
-            if h2.is_a?(Type::LocalHash)
+            if h2.is_a?(Type::Local) && h2.kind == Type::Hash
               h2_elems = scratch.get_container_elem_types(env, ep, h2.id)
               elems0 = h1_elems.union(h2_elems)
               if elems
@@ -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
@@ -142,8 +143,8 @@ 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]
+        scratch.warn(ep, "instance_eval with arguments is ignored")
+        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 is 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 is 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
@@ -187,6 +198,67 @@ module TypeProf
       end
     end
 
+    def module_public(recv, mid, aargs, ep, env, scratch, &ctn)
+      if aargs.lead_tys.empty?
+        ctn[recv, ep, env.method_public_set(true)]
+      else
+        aargs.lead_tys.each do |aarg|
+          sym = get_sym("public", aarg, ep, scratch) or next
+          meths = scratch.get_method(recv, false, sym)
+          next unless meths
+          meths.each do |mdef|
+            mdef.pub_meth = true
+          end
+        end
+        ctn[recv, ep, env]
+      end
+    end
+
+    def module_private(recv, mid, aargs, ep, env, scratch, &ctn)
+      if aargs.lead_tys.empty?
+        ctn[recv, ep, env.method_public_set(false)]
+      else
+        aargs.lead_tys.each do |aarg|
+          sym = get_sym("private", aarg, ep, scratch) or next
+          meths = scratch.get_method(recv, false, sym)
+          next unless meths
+          meths.each do |mdef|
+            mdef.pub_meth = false
+          end
+        end
+        ctn[recv, ep, env]
+      end
+    end
+
+    def module_define_method(recv, mid, aargs, ep, env, scratch, &ctn)
+      if aargs.lead_tys.size != 1
+        scratch.warn(ep, "Module#define with #{ aargs.lead_tys.size } argument is ignored")
+        ctn[Type.any, ep, env]
+        return
+      end
+
+      mid, = aargs.lead_tys
+      if mid.is_a?(Type::Symbol)
+        mid = mid.sym
+        aargs.blk_ty.each_child do |blk_ty|
+          if blk_ty.is_a?(Type::Proc)
+            blk = blk_ty.block_body
+            case blk
+            when ISeqBlock
+              scratch.do_define_iseq_method(ep, env, mid, blk.iseq, ep)
+            else
+              # XXX: what to do?
+            end
+          else
+            # XXX: what to do?
+          end
+        end
+      else
+        # XXX: what to do?
+      end
+      ctn[Type.any, ep, env]
+    end
+
     def module_attr_accessor(recv, mid, aargs, ep, env, scratch, &ctn)
       aargs.lead_tys.each do |aarg|
         sym = get_sym("attr_accessor", aarg, ep, scratch) or next
@@ -222,21 +294,16 @@ module TypeProf
     end
 
     def array_aref(recv, mid, aargs, ep, env, scratch, &ctn)
-      return ctn[Type.any, ep, env] unless recv.is_a?(Type::LocalArray)
+      return ctn[Type.any, ep, env] unless recv.is_a?(Type::Local) && recv.kind == Type::Array
 
       case aargs.lead_tys.size
       when 1
         idx = aargs.lead_tys.first
         if idx.is_a?(Type::Literal)
           idx = idx.lit
-          if idx.is_a?(Range)
-            ty = scratch.get_array_elem_type(env, ep, recv.id)
-            base_ty = Type::Instance.new(Type::Builtin[:ary])
-            ret_ty = Type::Array.new(Type::Array::Elements.new([], ty), base_ty)
-            ctn[ret_ty, ep, env]
-            return
-          end
-          idx = nil if !idx.is_a?(Integer)
+          idx = nil if !idx.is_a?(Integer) && !idx.is_a?(Range)
+        elsif idx == Type::Instance.new(Type::Builtin[:range])
+          idx = (nil..nil)
         else
           idx = nil
         end
@@ -253,7 +320,7 @@ module TypeProf
     end
 
     def array_aset(recv, mid, aargs, ep, env, scratch, &ctn)
-      return ctn[Type.any, ep, env] unless recv.is_a?(Type::LocalArray)
+      return ctn[Type.any, ep, env] unless recv.is_a?(Type::Local) && recv.kind == Type::Array
 
       if aargs.lead_tys.size != 2
         #raise NotImplementedError # XXX
@@ -278,7 +345,7 @@ module TypeProf
     end
 
     def array_pop(recv, mid, aargs, ep, env, scratch, &ctn)
-      return ctn[Type.any, ep, env] unless recv.is_a?(Type::LocalArray)
+      return ctn[Type.any, ep, env] unless recv.is_a?(Type::Local) && recv.kind == Type::Array
 
       if aargs.lead_tys.size != 0
         ctn[Type.any, ep, env]
@@ -290,7 +357,7 @@ module TypeProf
     end
 
     def hash_aref(recv, mid, aargs, ep, env, scratch, &ctn)
-      return ctn[Type.any, ep, env] unless recv.is_a?(Type::LocalHash)
+      return ctn[Type.any, ep, env] unless recv.is_a?(Type::Local) && recv.kind == Type::Hash
 
       if aargs.lead_tys.size != 1
         ctn[Type.any, ep, env]
@@ -298,7 +365,7 @@ module TypeProf
       end
       idx = aargs.lead_tys.first
       recv.each_child do |recv|
-        if recv.is_a?(Type::LocalHash)
+        if recv.is_a?(Type::Local) && recv.kind == Type::Hash
           ty = scratch.get_hash_elem_type(env, ep, recv.id, idx)
         else
           ty = Type.any
@@ -308,7 +375,7 @@ module TypeProf
     end
 
     def hash_aset(recv, mid, aargs, ep, env, scratch, &ctn)
-      return ctn[Type.any, ep, env] unless recv.is_a?(Type::LocalHash)
+      return ctn[Type.any, ep, env] unless recv.is_a?(Type::Local) && recv.kind == Type::Hash
 
       raise NotImplementedError if aargs.lead_tys.size != 2
 
@@ -316,7 +383,7 @@ module TypeProf
       idx = scratch.globalize_type(idx, env, ep)
       ty = aargs.lead_tys.last
 
-      unless recv.is_a?(Type::LocalHash)
+      unless recv.is_a?(Type::Local) && recv.kind == Type::Hash
         # to ignore: class OptionMap < Hash
         return ctn[ty, ep, env]
       end
@@ -473,6 +540,31 @@ module TypeProf
       ctn[result, ep, env]
     end
 
+    def kernel_autoload(recv, mid, aargs, ep, env, scratch, &ctn)
+      raise NotImplementedError if aargs.lead_tys.size != 2
+      feature = aargs.lead_tys[1]
+      if feature.is_a?(Type::Literal)
+        feature = feature.lit
+
+        action, arg = Builtin.file_require(feature, scratch)
+        case action
+        when :do
+          Builtin.file_load(arg, ep, env, scratch, &ctn)
+        when :done
+        when :error
+          scratch.warn(ep, arg)
+        end
+        ctn[Type.nil, ep, env]
+      else
+        scratch.warn(ep, "autoload target cannot be identified statically")
+        ctn[Type.nil, ep, env]
+      end
+    end
+
+    def module_autoload(recv, mid, aargs, ep, env, scratch, &ctn)
+      kernel_autoload(recv, mid, aargs, ep, env, scratch, &ctn)
+    end
+
     def kernel_Array(recv, mid, aargs, ep, env, scratch, &ctn)
       raise NotImplementedError if aargs.lead_tys.size != 1
       ty = aargs.lead_tys.first
@@ -546,6 +638,9 @@ module TypeProf
       scratch.set_custom_method(klass_module, :include, Builtin.method(:module_include))
       scratch.set_custom_method(klass_module, :extend, Builtin.method(:module_extend))
       scratch.set_custom_method(klass_module, :module_function, Builtin.method(:module_module_function))
+      scratch.set_custom_method(klass_module, :public, Builtin.method(:module_public))
+      scratch.set_custom_method(klass_module, :private, Builtin.method(:module_private))
+      scratch.set_custom_method(klass_module, :define_method, Builtin.method(:module_define_method))
 
       scratch.set_custom_method(klass_proc, :[], Builtin.method(:proc_call))
       scratch.set_custom_method(klass_proc, :call, Builtin.method(:proc_call))
@@ -563,6 +658,11 @@ module TypeProf
       scratch.set_custom_method(klass_obj, :require, Builtin.method(:kernel_require))
       scratch.set_custom_method(klass_obj, :require_relative, Builtin.method(:kernel_require_relative))
       scratch.set_custom_method(klass_obj, :Array, Builtin.method(:kernel_Array))
+      scratch.set_custom_method(klass_obj, :autoload, Builtin.method(:kernel_autoload))
+      scratch.set_custom_method(klass_module, :autoload, Builtin.method(:module_autoload))
+
+      # remove BasicObject#method_missing
+      scratch.set_method(klass_basic_obj, :method_missing, false, nil)
 
       # ENV: Hash[String, String]
       str_ty = Type::Instance.new(Type::Builtin[:str])

data/lib/typeprof/cli.rb

@@ -7,60 +7,59 @@ module TypeProf
     def parse(argv)
       opt = OptionParser.new
 
+      opt.banner = "Usage: #{ opt.program_name } [options] files..."
+
       output = nil
 
       # Verbose level:
-      # * 0: no output
-      # * 1: show indicator
-      # * 2: debug print
+      # * 0: none
+      # * 1: default level
+      # * 2: debugging level
       verbose = 1
 
       options = {}
       dir_filter = nil
       gem_rbs_features = []
-      version = false
+      show_version = false
       max_sec = max_iter = nil
 
-      opt.on("-o OUTFILE") {|v| output = v }
-      opt.on("-q", "--quiet") { verbose = 0 }
-      opt.on("-v", "--verbose") { options[:show_errors] = true }
-      opt.on("--version") { version = true }
-      opt.on("-d", "--debug") { verbose = 2 }
-      opt.on("-I DIR") {|v| $LOAD_PATH << v }
-      opt.on("-r FEATURE") {|v| gem_rbs_features << v }
-      opt.on("--max-second SECOND", Float) {|v| max_sec = v }
-      opt.on("--max-iteration TIMES", Integer) {|v| max_iter = v }
+      opt.separator ""
+      opt.separator "Options:"
+      opt.on("-o OUTFILE", "Output to OUTFILE instead of stdout") {|v| output = v }
+      opt.on("-q", "--quiet", "Do not display progress indicator") { options[:show_indicator] = false }
+      opt.on("-v", "--verbose", "Alias to --show-errors") { options[:show_errors] = true }
+      opt.on("--version", "Display typeprof version") { show_version = true }
+      opt.on("-I DIR", "Add DIR to the load/require path") {|v| $LOAD_PATH << v }
+      opt.on("-r FEATURE", "Require RBS of the FEATURE gem") {|v| gem_rbs_features << v }
 
-      opt.on("--include-dir DIR") do |dir|
+      opt.separator ""
+      opt.separator "Analysis output options:"
+      opt.on("--include-dir DIR", "Include the analysis result of .rb file in DIR") do |dir|
         # When `--include-dir` option is specified as the first directory option,
         # typeprof will exclude any files by default unless a file path matches the explicit option
         dir_filter ||= [[:exclude]]
         dir_filter << [:include, File.expand_path(dir)]
       end
-      opt.on("--exclude-dir DIR") do |dir|
+      opt.on("--exclude-dir DIR", "Exclude the analysis result of .rb file in DIR") do |dir|
         # When `--exclude-dir` option is specified as the first directory option,
         # typeprof will include any files by default, except Ruby's install directory and Gem directories
         dir_filter ||= ConfigData::DEFAULT_DIR_FILTER
         dir_filter << [:exclude, File.expand_path(dir)]
       end
+      opt.on("--[no-]show-errors", "Display possible errors found during the analysis") {|v| options[:show_errors] = v }
+      opt.on("--[no-]show-untyped", "Display \"Foo | untyped\" instead of \"Foo\"") {|v| options[:show_untyped] = v }
 
-      opt.on("-f OPTION") do |v|
-        key, args = v.split("=", 2)
-        case key
-        when "type-depth-limit"
-          options[:type_depth_limit] = Integer(args)
-        when "pedantic-output"
-          options[:pedantic_output] = true
-        when "show-errors"
-          options[:show_errors] = true
-        when "show-container-raw-elements"
-          options[:show_container_raw_elements] = true
-        when "stackprof"
-          options[:stackprof] = args ? args.to_sym : :cpu
-        else
-          raise OptionParser::InvalidOption.new("unknown option: #{ key }")
-        end
-      end
+      opt.separator ""
+      opt.separator "Analysis limit options:"
+      opt.on("--max-second SECOND", Float, "Limit the maxium time of analysis (in second)") {|v| max_sec = v }
+      opt.on("--max-iteration TIMES", Integer, "Limit the maxium instruction count of analysis") {|v| max_iter = v }
+
+      opt.separator ""
+      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("--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 }
 
       opt.parse!(argv)
 
@@ -75,9 +74,9 @@ module TypeProf
         end
       end
 
-      puts "typeprof #{ VERSION }" if version
+      puts "typeprof #{ VERSION }" if show_version
       if rb_files.empty?
-        exit if version
+        exit if show_version
         raise OptionParser::InvalidOption.new("no input files")
       end
 

data/lib/typeprof/config.rb

@@ -22,9 +22,11 @@ module TypeProf
       opt[:verbose] ||= 0
       opt[:options] ||= {}
       opt[:options] = {
-        type_depth_limit: 5,
-        pedantic_output: false,
+        show_indicator: true,
+        show_untyped: false,
         show_errors: false,
+        stub_execution: true,
+        type_depth_limit: 5,
         stackprof: nil,
       }.merge(opt[:options])
       super(**opt)
@@ -67,7 +69,7 @@ module TypeProf
 
     prologue_ctx = Context.new(nil, nil, nil)
     prologue_ep = ExecutionPoint.new(prologue_ctx, -1, nil)
-    prologue_env = Env.new(StaticEnv.new(:top, Type.nil, false), [], [], Utils::HashWrapper.new({}))
+    prologue_env = Env.new(StaticEnv.new(:top, Type.nil, false, true), [], [], Utils::HashWrapper.new({}))
 
     Config.rb_files.each do |rb|
       if rb.is_a?(Array) # [String name, String content]
@@ -111,7 +113,7 @@ module TypeProf
     ctx = Context.new(iseq, cref, nil)
     ep = ExecutionPoint.new(ctx, 0, nil)
     locals = [Type.nil] * iseq.locals.size
-    env = Env.new(StaticEnv.new(recv, Type.nil, false), locals, [], Utils::HashWrapper.new({}))
+    env = Env.new(StaticEnv.new(recv, Type.nil, false, false), locals, [], Utils::HashWrapper.new({}))
 
     return ep, env
   end

data/lib/typeprof/container-type.rb

@@ -77,7 +77,9 @@ module TypeProf
         return env, Type.any if depth <= 0
         alloc_site = alloc_site.add_id(:cell).add_id(@base_type)
         env, elems = @elems.localize(env, alloc_site, depth)
-        env.deploy_type(LocalCell, alloc_site, elems, @base_type)
+        ty = Local.new(Cell, alloc_site, @base_type)
+        env = env.deploy_type(alloc_site, elems)
+        return env, ty
       end
 
       def limit_size(limit)
@@ -85,7 +87,7 @@ module TypeProf
         Cell.new(@elems.limit_size(limit - 1), @base_type)
       end
 
-      def get_method(mid, scratch)
+      def method_dispatch_info
         raise
       end
 
@@ -95,6 +97,19 @@ module TypeProf
         Cell.new(elems, @base_type)
       end
 
+      def generate_substitution
+        subst = {}
+        tyvars = @base_type.klass.type_params.map {|name,| Type::Var.new(name) }
+        tyvars.zip(@elems.elems) do |tyvar, elem|
+          if subst[tyvar]
+            subst[tyvar] = subst[tyvar].union(elem)
+          else
+            subst[tyvar] = elem
+          end
+        end
+        subst
+      end
+
       class Elements # Cell
         include Utils::StructuralEquality
 
@@ -102,10 +117,14 @@ module TypeProf
           @elems = elems
         end
 
+        def self.dummy_elements
+          Elements.new([]) # XXX
+        end
+
         attr_reader :elems
 
         def to_local_type(id, base_ty)
-          Type::LocalCell.new(id, base_ty)
+          Type::Local.new(Cell, id, base_ty)
         end
 
         def globalize(env, visited, depth)
@@ -180,45 +199,6 @@ module TypeProf
       end
     end
 
-    class LocalCell < ContainerType
-      def initialize(id, base_type)
-        @id = id
-        raise unless base_type
-        @base_type = base_type
-      end
-
-      attr_reader :id, :base_type
-
-      def inspect
-        "Type::LocalCell[#{ @id }, base_type: #{ @base_type.inspect }]"
-      end
-
-      def screen_name(scratch)
-        #raise "LocalArray must not be included in signature"
-        "LocalCell!"
-      end
-
-      def globalize(env, visited, depth)
-        if visited[self] || depth <= 0
-          Type.any
-        else
-          visited[self] = true
-          elems = env.get_container_elem_types(@id)
-          if elems
-            elems = elems.globalize(env, visited, depth - 1)
-          else
-            elems = Cell::Elements.new([]) # XXX
-          end
-          visited.delete(self)
-          Cell.new(elems, @base_type)
-        end
-      end
-
-      def get_method(mid, scratch)
-        @base_type.get_method(mid, scratch)
-      end
-    end
-
     # Do not insert Array type to local environment, stack, etc.
     class Array < ContainerType
       def initialize(elems, base_type)
@@ -228,6 +208,10 @@ module TypeProf
         @base_type = base_type
       end
 
+      def self.dummy_elements
+        Elements.new([], Type.any)
+      end
+
       attr_reader :elems, :base_type
 
       def inspect
@@ -247,7 +231,9 @@ module TypeProf
         return env, Type.any if depth <= 0
         alloc_site = alloc_site.add_id(:ary).add_id(@base_type)
         env, elems = @elems.localize(env, alloc_site, depth - 1)
-        env.deploy_type(LocalArray, alloc_site, elems, @base_type)
+        ty = Local.new(Array, alloc_site, @base_type)
+        env = env.deploy_type(alloc_site, elems)
+        return env, ty
       end
 
       def limit_size(limit)
@@ -255,7 +241,7 @@ module TypeProf
         Array.new(@elems.limit_size(limit - 1), @base_type)
       end
 
-      def get_method(mid, scratch)
+      def method_dispatch_info
         raise
       end
 
@@ -265,6 +251,10 @@ module TypeProf
         Array.new(elems, @base_type)
       end
 
+      def generate_substitution
+        { Type::Var.new(:Elem) => @elems.squash }
+      end
+
       class Elements # Array
         include Utils::StructuralEquality
 
@@ -277,7 +267,7 @@ module TypeProf
         attr_reader :lead_tys, :rest_ty
 
         def to_local_type(id, base_ty)
-          Type::LocalArray.new(id, base_ty)
+          Type::Local.new(Array, id, base_ty)
         end
 
         def globalize(env, visited, depth)
@@ -305,7 +295,10 @@ module TypeProf
         end
 
         def screen_name(scratch)
-          if Config.options[:show_container_raw_elements] || @rest_ty == Type.bot
+          if @rest_ty == Type.bot
+            if @lead_tys.empty?
+              return "Array[bot]" # RBS does not allow an empty tuple "[]"
+            end
             s = @lead_tys.map do |ty|
               ty.screen_name(scratch)
             end
@@ -360,7 +353,57 @@ module TypeProf
         end
 
         def [](idx)
-          if idx >= 0
+          if idx.is_a?(Range)
+            if @rest_ty == Type.bot
+              lead_tys = @lead_tys[idx]
+              if lead_tys
+                rest_ty = Type.bot
+              else
+                return Type.nil
+              end
+            else
+              b, e = idx.begin, idx.end
+              b = 0 if !b
+              if !e
+                lead_tys = @lead_tys[idx] || []
+                rest_ty = @rest_ty
+              elsif b >= 0
+                if e >= 0
+                  if b <= e
+                    if e < @lead_tys.size
+                      lead_tys = @lead_tys[idx]
+                      rest_ty = Type.bot
+                    else
+                      lead_tys = @lead_tys[idx] || []
+                      rest_ty = @rest_ty
+                    end
+                  else
+                    return Type.nil
+                  end
+                else
+                  lead_tys = @lead_tys[idx] || []
+                  e = idx.exclude_end? ? e : e == -1 ? @lead_tys.size : e + 1
+                  rest_ty = (@lead_tys[e + 1..] || []).inject(@rest_ty) {|ty0, ty1| ty0.union(ty1) }
+                end
+              else
+                lead_tys = []
+                if e >= 0
+                  rest_ty = e < @lead_tys.size ? Type.bot : @rest_ty
+                  range = [0, @lead_tys.size + b].max .. (idx.exclude_end? ? e - 1 : e)
+                  rest_ty = @lead_tys[range].inject(rest_ty) {|ty0, ty1| ty0.union(ty1) }
+                else
+                  if b <= e
+                    range = [0, @lead_tys.size + b].max .. (idx.exclude_end? ? e - 1 : e)
+                    rest_ty = @lead_tys[range].inject(@rest_ty) {|ty0, ty1| ty0.union(ty1) }
+                  else
+                    return Type.nil
+                  end
+                end
+              end
+            end
+            base_ty = Type::Instance.new(Type::Builtin[:ary])
+            Array.new(Elements.new(lead_tys, rest_ty), base_ty)
+          elsif idx >= 0
             if idx < @lead_tys.size
               @lead_tys[idx]
             elsif @rest_ty == Type.bot
@@ -491,48 +534,6 @@ module TypeProf
       end
     end
 
-    # Do not insert Array type to local environment, stack, etc.
-    class LocalArray < ContainerType
-      def initialize(id, base_type)
-        @id = id
-        raise unless base_type
-        @base_type = base_type
-      end
-
-      attr_reader :id, :base_type
-
-      def inspect
-        "Type::LocalArray[#{ @id }, base_type: #{ @base_type.inspect }]"
-      end
-
-      def screen_name(scratch)
-        #raise "LocalArray must not be included in signature"
-        "LocalArray!"
-      end
-
-      def globalize(env, visited, depth)
-        if visited[self] || depth <= 0
-          Type.any
-        else
-          visited[self] = true
-          elems = env.get_container_elem_types(@id)
-          if elems
-            elems = elems.globalize(env, visited, depth - 1)
-          else
-            # TODO: currently out-of-scope array cannot be accessed
-            elems = Array::Elements.new([], Type.any)
-          end
-          visited.delete(self)
-          Array.new(elems, @base_type)
-        end
-      end
-
-      def get_method(mid, scratch)
-        @base_type.get_method(mid, scratch)
-      end
-    end
-
-
     class Hash < ContainerType
       def initialize(elems, base_type)
         @elems = elems
@@ -554,7 +555,9 @@ module TypeProf
         return env, Type.any if depth <= 0
         alloc_site = alloc_site.add_id(:hash).add_id(@base_type)
         env, elems = @elems.localize(env, alloc_site, depth - 1)
-        env.deploy_type(LocalHash, alloc_site, elems, @base_type)
+        ty = Local.new(Hash, alloc_site, @base_type)
+        env = env.deploy_type(alloc_site, elems)
+        return env, ty
       end
 
       def limit_size(limit)
@@ -562,7 +565,7 @@ module TypeProf
         Hash.new(@elems.limit_size(limit - 1), @base_type)
       end
 
-      def get_method(mid, scratch)
+      def method_dispatch_info
         raise
       end
 
@@ -572,6 +575,14 @@ module TypeProf
         Hash.new(elems, @base_type)
       end
 
+      def generate_substitution
+        tyvar_k = Type::Var.new(:K)
+        tyvar_v = Type::Var.new(:V)
+        k_ty0, v_ty0 = @elems.squash
+        # XXX: need to heuristically replace ret type Hash[K, V] with self, instead of conversative type?
+        { tyvar_k => k_ty0, tyvar_v => v_ty0 }
+      end
+
       class Elements # Hash
         include Utils::StructuralEquality
 
@@ -580,18 +591,21 @@ module TypeProf
             raise unless k_ty.is_a?(Type)
             raise unless v_ty.is_a?(Type)
             raise if k_ty.is_a?(Type::Union)
-            raise if k_ty.is_a?(Type::LocalArray)
-            raise if k_ty.is_a?(Type::LocalHash)
+            raise if k_ty.is_a?(Type::Local)
             raise if k_ty.is_a?(Type::Array)
             raise if k_ty.is_a?(Type::Hash)
           end
           @map_tys = map_tys
         end
 
+        def self.dummy_elements
+          Elements.new({Type.any => Type.any})
+        end
+
         attr_reader :map_tys
 
         def to_local_type(id, base_ty)
-          Type::LocalHash.new(id, base_ty)
+          Type::Local.new(Hash, id, base_ty)
         end
 
         def globalize(env, visited, depth)
@@ -631,16 +645,22 @@ module TypeProf
         end
 
         def screen_name(scratch)
-          s = @map_tys.map do |k_ty, v_ty|
-            v = v_ty.screen_name(scratch)
-            if k_ty.is_a?(Type::Symbol)
+          if !@map_tys.empty? && @map_tys.all? {|k_ty,| k_ty.is_a?(Type::Symbol) }
+            s = @map_tys.map do |k_ty, v_ty|
+              v = v_ty.screen_name(scratch)
               "#{ k_ty.sym }: #{ v }"
-            else
-              k = k_ty.screen_name(scratch)
-              "#{ k }=>#{ v }"
+            end.join(", ")
+            "{#{ s }}"
+          else
+            k_ty = v_ty = Type.bot
+            @map_tys.each do |k, v|
+              k_ty = k_ty.union(k)
+              v_ty = v_ty.union(v)
             end
-          end.join(", ")
-          "{#{ s }}"
+            k_ty = k_ty.screen_name(scratch)
+            v_ty = v_ty.screen_name(scratch)
+            "Hash[#{ k_ty }, #{ v_ty }]"
+          end
         end
 
         def pretty_print(q)
@@ -773,21 +793,23 @@ module TypeProf
       end
     end
 
-    class LocalHash < ContainerType
-      def initialize(id, base_type)
+    class Local < ContainerType
+      def initialize(kind, id, base_type)
+        @kind = kind
         @id = id
+        raise unless base_type
         @base_type = base_type
       end
 
-      attr_reader :id, :base_type
+      attr_reader :kind, :id, :base_type
 
       def inspect
-        "Type::LocalHash[#{ @id }]"
+        "Type::Local[#{ @kind }, #{ @id }, base_type: #{ @base_type.inspect }]"
       end
 
       def screen_name(scratch)
-        #raise "LocalHash must not be included in signature"
-        "LocalHash!"
+        #raise "Local type must not be included in signature"
+        "Local[#{ @kind }]"
       end
 
       def globalize(env, visited, depth)
@@ -799,15 +821,56 @@ module TypeProf
           if elems
             elems = elems.globalize(env, visited, depth - 1)
           else
-            elems = Hash::Elements.new({Type.any => Type.any})
+            # TODO: currently out-of-scope array cannot be accessed
+            elems = @kind::Elements.dummy_elements
           end
           visited.delete(self)
-          Hash.new(elems, @base_type)
+          @kind.new(elems, @base_type)
         end
       end
 
-      def get_method(mid, scratch)
-        @base_type.get_method(mid, scratch)
+      def method_dispatch_info
+        @base_type.method_dispatch_info
+      end
+
+      def update_container_elem_type(subst, env, caller_ep, scratch)
+        case
+        when @kind == Cell
+          tyvars = @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
+              env, ty = scratch.localize_type(ty, env, caller_ep)
+              env = scratch.update_container_elem_types(env, caller_ep, @id, @base_type) do |elems|
+                elems.update(idx, ty)
+              end
+            end
+          end
+        when @kind == Array
+          tyvar_elem = Type::Var.new(:Elem)
+          if subst[tyvar_elem]
+            ty = subst[tyvar_elem]
+            env, ty = scratch.localize_type(ty, env, caller_ep)
+            env = scratch.update_container_elem_types(env, caller_ep, @id, @base_type) do |elems|
+              elems.update(nil, ty)
+            end
+          end
+        when @kind == Hash
+          tyvar_k = Type::Var.new(:K)
+          tyvar_v = Type::Var.new(:V)
+          if subst[tyvar_k] && subst[tyvar_v]
+            k_ty = subst[tyvar_k]
+            v_ty = subst[tyvar_v]
+            alloc_site = AllocationSite.new(caller_ep)
+            env, k_ty = scratch.localize_type(k_ty, env, caller_ep, alloc_site.add_id(:k))
+            env, v_ty = scratch.localize_type(v_ty, env, caller_ep, alloc_site.add_id(:v))
+            env = scratch.update_container_elem_types(env, caller_ep, @id, @base_type) do |elems|
+              elems.update(k_ty, v_ty)
+            end
+          end
+        end
+        env
       end
     end
   end