typeprof 0.6.1 → 0.7.0

data/lib/typeprof/export.rb

@@ -139,7 +139,7 @@ module TypeProf
               iseq_methods[method_name] << @scratch.show_method_signature(ctx)
             end
           when AttrMethodDef
-            next if Config.check_dir_filter(mdef.absolute_path) == :exclude
+            next if !mdef.absolute_path || Config.check_dir_filter(mdef.absolute_path) == :exclude
             mid = mid.to_s[0..-2].to_sym if mid.to_s.end_with?("=")
             method_name = mid
             method_name = "self.#{ mid }" if singleton
@@ -168,12 +168,14 @@ module TypeProf
         next unless var.to_s.start_with?("@")
         var = "self.#{ var }" if singleton
         next if attr_methods[[singleton ? "self.#{ var.to_s[1..] }" : var.to_s[1..].to_sym, false]]
-        [var, ty.screen_name(@scratch), entry.rbs_declared]
+        next if entry.rbs_declared
+        [var, ty.screen_name(@scratch)]
       end.compact
 
       cvars = cvars.map do |var, entry|
         next if entry.absolute_paths.all? {|path| Config.check_dir_filter(path) == :exclude }
-        [var, entry.type.screen_name(@scratch), entry.rbs_declared]
+        next if entry.rbs_declared
+        [var, entry.type.screen_name(@scratch)]
       end.compact
 
       if !class_def.absolute_path || Config.check_dir_filter(class_def.absolute_path) == :exclude
@@ -277,14 +279,12 @@ module TypeProf
         output.puts indent + "  extend #{ mod }"
         first = false
       end
-      class_data.ivars.each do |var, ty, rbs_declared|
-        s = rbs_declared ? "# " : "  "
-        output.puts indent + s + "#{ var } : #{ ty }" unless var.start_with?("_")
+      class_data.ivars.each do |var, ty|
+        output.puts indent + "  #{ var } : #{ ty }" unless var.start_with?("_")
         first = false
       end
-      class_data.cvars.each do |var, ty, rbs_declared|
-        s = rbs_declared ? "# " : "  "
-        output.puts indent + s + "#{ var } : #{ ty }"
+      class_data.cvars.each do |var, ty|
+        output.puts indent + "  #{ var } : #{ ty }"
         first = false
       end
       class_data.attr_methods.each do |(method_name, hidden), (kind, ty)|

data/lib/typeprof/import.rb

@@ -113,6 +113,7 @@ module TypeProf
         included_modules = []
         extended_modules = []
         methods = {}
+        attr_methods = {}
         ivars = {}
         cvars = {}
         rbs_sources = {}
@@ -148,15 +149,15 @@ module TypeProf
               end
             when RBS::AST::Members::AttrReader
               ty = conv_type(member.type)
-              methods[[false, member.name]] = attr_reader_def(ty)
+              attr_methods[[false, member.name]] = attr_method_def(:reader, member.name, ty)
             when RBS::AST::Members::AttrWriter
               ty = conv_type(member.type)
-              methods[[false, :"#{ member.name }="]] = attr_writer_def(ty)
+              attr_methods[[false, member.name]] = attr_method_def(:writer, member.name, ty)
             when RBS::AST::Members::AttrAccessor
               ty = conv_type(member.type)
-              methods[[false, member.name]] = attr_reader_def(ty)
-              methods[[false, :"#{ member.name }="]] = attr_writer_def(ty)
+              attr_methods[[false, member.name]] = attr_method_def(:accessor, member.name, ty)
             when RBS::AST::Members::Alias
+              # XXX: an alias to attr methods?
               if member.instance?
                 method_def = methods[[false, member.old_name]]
                 methods[[false, member.new_name]] = method_def if method_def
@@ -212,6 +213,7 @@ module TypeProf
             included_modules: included_modules,
             extended_modules: extended_modules,
             methods: methods,
+            attr_methods: attr_methods,
             ivars: ivars,
             cvars: cvars,
             rbs_sources: rbs_sources,
@@ -308,7 +310,7 @@ module TypeProf
       opt_kw_tys = func.optional_keywords.to_h {|key, type| [key, conv_type(type.type)] }
       req_kw_tys = func.required_keywords.to_h {|key, type| [key, conv_type(type.type)] }
       rest_kw_ty = func.rest_keywords
-      raise NotImplementedError if rest_kw_ty # XXX
+      rest_kw_ty = conv_type(rest_kw_ty.type) if rest_kw_ty
 
       ret_ty = conv_type(func.return_type)
 
@@ -325,32 +327,12 @@ module TypeProf
       }
     end
 
-    def attr_reader_def(ty)
-      [{
-        type_params: [],
-        lead_tys: [],
-        opt_tys: [],
-        rest_ty: nil,
-        req_kw_tys: {},
-        opt_kw_tys: {},
-        rest_kw_ty: nil,
-        blk: nil,
-        ret_ty: ty,
-      }]
-    end
-
-    def attr_writer_def(ty)
-      [{
-        type_params: [],
-        lead_tys: [ty],
-        opt_tys: [],
-        rest_ty: nil,
-        req_kw_tys: {},
-        opt_kw_tys: {},
-        rest_kw_ty: nil,
-        blk: nil,
-        ret_ty: ty,
-      }]
+    def attr_method_def(kind, name, ty)
+      {
+        kind: kind,
+        ivar: name,
+        ty: ty,
+      }
     end
 
     def conv_block(rbs_block)
@@ -518,6 +500,7 @@ module TypeProf
         included_modules = members[:included_modules]
         extended_modules = members[:extended_modules]
         methods = members[:methods]
+        attr_methods = members[:attr_methods]
         ivars = members[:ivars]
         cvars = members[:cvars]
         rbs_sources = members[:rbs_sources]
@@ -538,6 +521,14 @@ module TypeProf
           @scratch.add_method(klass, method_name, singleton, mdef)
         end
 
+        attr_methods.each do |(singleton, method_name), mdef|
+          kind = mdef[:kind]
+          ivar = mdef[:ivar]
+          ty = conv_type(mdef[:ty]).remove_type_vars
+          @scratch.add_attr_method(klass, nil, ivar, :"@#{ ivar }", kind)
+          @scratch.add_ivar_write!(Type::Instance.new(klass), :"@#{ ivar }", ty, nil)
+        end
+
         ivars.each do |ivar_name, ty|
           ty = conv_type(ty).remove_type_vars
           @scratch.add_ivar_write!(Type::Instance.new(klass), ivar_name, ty, nil)
@@ -604,7 +595,7 @@ module TypeProf
       req, lead_tys, opt_tys, ret_ty = blk
       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, nil, nil, nil)
+      msig = MethodSignature.new(lead_tys, opt_tys, nil, [], {}, nil, 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

data/lib/typeprof/method.rb

@@ -4,10 +4,11 @@ module TypeProf
   end
 
   class ISeqMethodDef < MethodDef
-    def initialize(iseq, cref)
+    def initialize(iseq, cref, outer_ep)
       @iseq = iseq
       raise if iseq.nil?
       @cref = cref
+      @outer_ep = outer_ep
     end
 
     def do_send(recv, mid, aargs, caller_ep, caller_env, scratch, &ctn)
@@ -25,7 +26,7 @@ module TypeProf
       end
 
       nctx = Context.new(@iseq, @cref, mid)
-      callee_ep = ExecutionPoint.new(nctx, 0, nil)
+      callee_ep = ExecutionPoint.new(nctx, 0, @outer_ep)
       nenv = Env.new(StaticEnv.new(recv, blk_ty, false), locals, [], Utils::HashWrapper.new({}))
       alloc_site = AllocationSite.new(callee_ep)
       locals.each_with_index do |ty, i|
@@ -44,6 +45,14 @@ module TypeProf
     end
 
     def do_check_send(msig, recv, mid, ep, scratch)
+      klass, singleton = recv.method_dispatch_info
+      cur_subst = {}
+      direct_method = true
+      scratch.adjust_substitution(klass, singleton, mid, self, recv.generate_substitution) do |subst, direct|
+        direct_method &&= direct
+        cur_subst = Type.merge_substitution(cur_subst, subst)
+      end
+
       lead_num = @iseq.fargs_format[:lead_num] || 0
       post_num = @iseq.fargs_format[:post_num] || 0
       rest_start = @iseq.fargs_format[:rest_start]
@@ -67,7 +76,8 @@ module TypeProf
       post_start = @iseq.fargs_format[:post_start]
       rest_start = @iseq.fargs_format[:rest_start]
       kw_start = @iseq.fargs_format[:kwbits]
-      kw_start -= @iseq.fargs_format[:keyword].size if kw_start
+      keyword = @iseq.fargs_format[:keyword]
+      kw_start -= keyword.size if kw_start
       kw_rest = @iseq.fargs_format[:kwrest]
       block_start = @iseq.fargs_format[:block_start]
 
@@ -83,12 +93,14 @@ module TypeProf
       msig.lead_tys.each_with_index do |ty, i|
         alloc_site2 = alloc_site.add_id(idx += 1)
         # nenv is top-level, so it is okay to call Type#localize directly
+        ty = ty.substitute(cur_subst, Config.options[:type_depth_limit]).remove_type_vars
         nenv, ty = ty.localize(nenv, alloc_site2, Config.options[:type_depth_limit])
         nenv = nenv.local_update(i, ty)
       end
       if msig.opt_tys
         msig.opt_tys.each_with_index do |ty, i|
           alloc_site2 = alloc_site.add_id(idx += 1)
+          ty = ty.substitute(cur_subst, Config.options[:type_depth_limit]).remove_type_vars
           nenv, ty = ty.localize(nenv, alloc_site2, Config.options[:type_depth_limit])
           nenv = nenv.local_update(lead_num + i, ty)
         end
@@ -96,19 +108,27 @@ module TypeProf
       if msig.rest_ty
         alloc_site2 = alloc_site.add_id(idx += 1)
         ty = Type::Array.new(Type::Array::Elements.new([], msig.rest_ty), Type::Instance.new(Type::Builtin[:ary]))
+        ty = ty.substitute(cur_subst, Config.options[:type_depth_limit]).remove_type_vars
         nenv, rest_ty = ty.localize(nenv, alloc_site2, Config.options[:type_depth_limit])
         nenv = nenv.local_update(rest_start, rest_ty)
       end
       if msig.post_tys
         msig.post_tys.each_with_index do |ty, i|
           alloc_site2 = alloc_site.add_id(idx += 1)
+          ty = ty.substitute(cur_subst, Config.options[:type_depth_limit]).remove_type_vars
           nenv, ty = ty.localize(nenv, alloc_site2, Config.options[:type_depth_limit])
           nenv = nenv.local_update(post_start + i, ty)
         end
       end
       if msig.kw_tys
-        msig.kw_tys.each_with_index do |(_, key, ty), i|
+        msig.kw_tys.each do |_, key, ty|
+          i = keyword.index(key)
+          unless i
+            # warn
+            next
+          end
           alloc_site2 = alloc_site.add_id(key)
+          ty = ty.substitute(cur_subst, Config.options[:type_depth_limit]).remove_type_vars
           nenv, ty = ty.localize(nenv, alloc_site2, Config.options[:type_depth_limit])
           nenv = nenv.local_update(kw_start + i, ty)
         end
@@ -116,6 +136,7 @@ module TypeProf
       if msig.kw_rest_ty
         ty = msig.kw_rest_ty
         alloc_site2 = alloc_site.add_id(:**)
+        ty = ty.substitute(cur_subst, Config.options[:type_depth_limit]).remove_type_vars
         nenv, ty = ty.localize(nenv, alloc_site2, Config.options[:type_depth_limit])
         nenv = nenv.local_update(kw_rest, ty)
       end
@@ -171,30 +192,11 @@ 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|
+      direct_method = true
+      scratch.adjust_substitution(klass, singleton, mid, self, recv.generate_substitution) do |subst, direct|
+        direct_method &&= direct
         cur_subst = Type.merge_substitution(cur_subst, subst)
       end
 
@@ -206,45 +208,15 @@ module TypeProf
         # XXX: support self type in msig
         subst = aargs.consistent_with_method_signature?(msig)
         next unless 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) }
-          # XXX: This should be skipped when the called methods belongs to superclass
-          tyvars.each_with_index do |tyvar, idx|
-            ty = subst[tyvar]
-            if ty
-              ncaller_env, ty = scratch.localize_type(ty, ncaller_env, caller_ep)
-              ncaller_env = scratch.update_container_elem_types(ncaller_env, caller_ep, recv_orig.id, recv_orig.base_type) do |elems|
-                elems.update(idx, ty)
-              end
-            end
-          end
-        when recv.is_a?(Type::Array) && recv_orig.is_a?(Type::LocalArray)
-          tyvar_elem = Type::Var.new(:Elem)
-          if subst[tyvar_elem]
-            ty = subst[tyvar_elem]
-            ncaller_env, ty = scratch.localize_type(ty, ncaller_env, caller_ep)
-            ncaller_env = scratch.update_container_elem_types(ncaller_env, caller_ep, recv_orig.id, recv_orig.base_type) do |elems|
-              elems.update(nil, ty)
-            end
-          end
-        when recv.is_a?(Type::Hash) && recv_orig.is_a?(Type::LocalHash)
-          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)
-            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))
-            ncaller_env = scratch.update_container_elem_types(ncaller_env, caller_ep, recv_orig.id, recv_orig.base_type) do |elems|
-              elems.update(k_ty, v_ty)
-            end
-          end
+
+        if direct_method && recv_orig.is_a?(Type::Local)
+          ncaller_env = recv_orig.update_container_elem_type(subst, ncaller_env, caller_ep, scratch)
         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
@@ -255,88 +227,30 @@ module TypeProf
           dummy_env = Env.new(StaticEnv.new(s_recv, msig.blk_ty, false), [], [], Utils::HashWrapper.new({}))
           if msig.blk_ty.is_a?(Type::Proc)
             scratch.add_callsite!(dummy_ctx, caller_ep, ncaller_env, &ctn)
-            nfargs = msig.blk_ty.block_body.msig
+            bsig = msig.blk_ty.block_body.msig
             alloc_site = AllocationSite.new(caller_ep).add_id(self)
-            nlead_tys = (nfargs.lead_tys + nfargs.opt_tys).map.with_index do |ty, i|
-              if recv.is_a?(Type::Array)
-                tyvar_elem = Type::Var.new(:Elem)
-                ty = ty.substitute(subst.merge({ tyvar_elem => recv.elems.squash_or_any }), Config.options[:type_depth_limit])
-              else
-                ty = ty.substitute(subst, Config.options[:type_depth_limit])
-              end
-              ty = ty.remove_type_vars
-              alloc_site2 = alloc_site.add_id(i)
-              dummy_env, ty = scratch.localize_type(ty, dummy_env, dummy_ep, alloc_site2)
+            nlead_tys = (bsig.lead_tys + bsig.opt_tys).map.with_index do |ty, i|
+              ty = ty.substitute(subst, Config.options[:type_depth_limit]).remove_type_vars
+              dummy_env, ty = scratch.localize_type(ty, dummy_env, dummy_ep, alloc_site.add_id(i))
               ty
             end
-            0.upto(nfargs.opt_tys.size) do |n|
-              naargs = ActualArguments.new(nlead_tys[0, nfargs.lead_tys.size + n], nil, {}, Type.nil) # XXX: support block to block?
+            0.upto(bsig.opt_tys.size) do |n|
+              naargs = ActualArguments.new(nlead_tys[0, bsig.lead_tys.size + n], nil, {}, Type.nil) # XXX: support block to block?
               scratch.do_invoke_block(aargs.blk_ty, naargs, dummy_ep, dummy_env) do |blk_ret_ty, _ep, _env|
                 subst2 = Type.match?(blk_ret_ty, msig.blk_ty.block_body.ret_ty)
                 if subst2
                   subst2 = Type.merge_substitution(subst, subst2)
-                  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.each_with_index do |tyvar, idx|
-                      ty = subst2[tyvar]
-                      if ty
-                        ncaller_env, ty = scratch.localize_type(ty, ncaller_env, caller_ep)
-                        ncaller_env = scratch.update_container_elem_types(ncaller_env, caller_ep, recv_orig.id, recv_orig.base_type) do |elems|
-                          elems.update(idx, ty)
-                        end
-                        scratch.merge_return_env(caller_ep) {|env| env ? env.merge(ncaller_env) : ncaller_env }
-                      end
-                    end
-                    tyvars.zip(recv.elems.elems) do |tyvar, elem|
-                      if subst2[tyvar]
-                        subst2[tyvar] = subst2[tyvar].union(elem)
-                      else
-                        subst2[tyvar] = elem
-                      end
-                    end
-                    ret_ty = ret_ty.substitute(subst2, Config.options[:type_depth_limit])
-                  when recv.is_a?(Type::Array) && recv_orig.is_a?(Type::LocalArray)
-                    tyvar_elem = Type::Var.new(:Elem)
-                    if subst2[tyvar_elem]
-                      ty = subst2[tyvar_elem]
-                      ncaller_env, ty = scratch.localize_type(ty, ncaller_env, caller_ep)
-                      ncaller_env = scratch.update_container_elem_types(ncaller_env, caller_ep, recv_orig.id, recv_orig.base_type) do |elems|
-                        elems.update(nil, ty)
-                      end
-                      scratch.merge_return_env(caller_ep) {|env| env ? env.merge(ncaller_env) : ncaller_env }
-                    end
-                    ret_ty = ret_ty.substitute(subst2, Config.options[:type_depth_limit])
-                  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 subst2[tyvar_k] && subst2[tyvar_v]
-                      k_ty = subst2[tyvar_k]
-                      v_ty = subst2[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))
-                      ncaller_env = scratch.update_container_elem_types(ncaller_env, caller_ep, recv_orig.id, recv_orig.base_type) do |elems|
-                        elems.update(k_ty, v_ty)
-                      end
-                      scratch.merge_return_env(caller_ep) {|env| env ? env.merge(ncaller_env) : ncaller_env }
-                    end
-                    ret_ty = ret_ty.substitute(subst2, Config.options[:type_depth_limit])
-                  else
-                    ret_ty = ret_ty.substitute(subst2, Config.options[:type_depth_limit])
+                  if direct_method && recv_orig.is_a?(Type::Local)
+                    ncaller_env = recv_orig.update_container_elem_type(subst2, ncaller_env, caller_ep, scratch)
+                    scratch.merge_return_env(caller_ep) {|env| env ? env.merge(ncaller_env) : ncaller_env }
                   end
+                  ret_ty2 = ret_ty.substitute(subst2, Config.options[:type_depth_limit]).remove_type_vars
                 else
-                  # raise "???"
-                  # XXX: need warning
-                  ret_ty = Type.any
+                  ret_ty2 = Type.any
                 end
-                ret_ty = ret_ty.remove_type_vars
                 # XXX: check the return type from the block
                 # sig.blk_ty.block_body.ret_ty.eql?(_ret_ty) ???
-                scratch.add_return_value!(dummy_ctx, ret_ty)
+                scratch.add_return_value!(dummy_ctx, ret_ty2)
               end
               # scratch.add_return_value!(dummy_ctx, ret_ty) ?
               # This makes `def foo; 1.times { return "str" }; end` return Integer|String

data/lib/typeprof/type.rb

@@ -149,6 +149,10 @@ module TypeProf
       raise "cannot substitute abstract type: #{ self.class }"
     end
 
+    def generate_substitution
+      {}
+    end
+
     DummySubstitution = Object.new
     def DummySubstitution.[](_)
       Type.any
@@ -203,11 +207,12 @@ module TypeProf
         local = nil
         tys.each do |ty|
           raise ty.inspect unless ty.is_a?(Type)
-          local = true if ty.is_a?(LocalArray) || ty.is_a?(LocalHash)
+          local = true if ty.is_a?(Local)
         end
         raise if local && elems
 
         @elems = elems
+        raise elems.inspect if elems && !elems.is_a?(::Hash)
       end
 
       def each_free_type_variable(&blk)
@@ -285,7 +290,7 @@ module TypeProf
             types.delete(Type::Instance.new(Type::Builtin[:true]))
             bool = true
           end
-          types.delete(Type.any) unless Config.options[:pedantic_output]
+          types.delete(Type.any) unless Config.options[:show_untyped]
           proc_tys, types = types.partition {|ty| ty.is_a?(Proc) }
           types = types.map {|ty| ty.screen_name(scratch) }
           types << scratch.show_proc_signature(proc_tys) unless proc_tys.empty?
@@ -817,6 +822,7 @@ module TypeProf
       @opt_tys = opt_tys
       @rest_ty = rest_ty
       @post_tys = post_tys
+      raise unless post_tys
       @kw_tys = kw_tys
       kw_tys.each {|a| raise if a.size != 3 } if kw_tys
       @kw_rest_ty = kw_rest_ty