typeprof 0.4.1 → 0.5.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a7e8caeb25445b59db3abd2709deaf1e5395d5e5584ff8ce667e7b19ec5981da
-  data.tar.gz: b2bbe7c5c3d0218989c3f2f87a33d4c5c5e61355035dbe57b511a49eb9bc5879
+  metadata.gz: b1281ceb7a6a28b6dec33aad740d0fa52429a17ca29d57747717247fdb449c79
+  data.tar.gz: 3ad79ab67ba6080e0c1da2b46671012e4db2f886020a11772158449ffd85717b
 SHA512:
-  metadata.gz: b33bf9cb6c4ea92ddd0e7721693060bfce646873833603c18386039de90e8a6a51b8a2a6a146d401d51c0d066d4ba42f6c88ae11dc10e21b978f3bd04591a8a9
-  data.tar.gz: f6ae89fc7879efa8d06445a2c1efc04dcc76defae0a789978c14a786aa0d30ddacab5578fdde2d91bcfe5bd91a5022d6594bc9cf1971dceae8215cbc70b5fd36
+  metadata.gz: c0e888c0c1cc871b23592f29d138f7c9c8ca5370fa98699c9b504aa29c79796f58d97653fac98cef2df1d8e7f5c961942ee28d385a95695e4ce7f1ff3c8d24f5
+  data.tar.gz: 3ee4de72a8e26aed401b1879575ef82c0b1215fe9ccb87ee2c781a8138becc9ab948aea00e07e8e344ca4f96610ebfefdc540f175253cfe32dca1f721c232e7f

data/.github/workflows/main.yml

@@ -17,9 +17,8 @@ jobs:
       uses: ruby/setup-ruby@v1
       with:
         ruby-version: ${{ matrix.ruby-version }}
-    - name: Set up RBS and bundle install
+    - name: Bundle install
       run: |
-        cd rbs && bundle install && bundle exec rake parser && cd ..
         bundle install
     - name: Run the test suite
       run: |

data/Gemfile.lock

@@ -1,8 +1,8 @@
 PATH
   remote: .
   specs:
-    typeprof (0.4.0)
-      rbs (>= 0.16.0)
+    typeprof (0.5.2)
+      rbs (>= 0.17.0)
 
 GEM
   remote: https://rubygems.org/
@@ -11,7 +11,7 @@ GEM
     docile (1.3.2)
     power_assert (1.2.0)
     rake (13.0.1)
-    rbs (0.16.0)
+    rbs (0.17.0)
     simplecov (0.19.1)
       docile (~> 1.1)
       simplecov-html (~> 0.11)

data/README.md

@@ -33,3 +33,9 @@ end
 ## Documentation
 
 [English](doc/doc.md) / [日本語](doc/doc.ja.md)
+
+## Playground
+
+You can try typeprof gem on the Web via the URL below.
+
+https://mame.github.io/typeprof-playground/

data/lib/typeprof/analyzer.rb

@@ -87,6 +87,11 @@ module TypeProf
       @recv_ty = recv_ty
       @blk_ty = blk_ty
       @mod_func = mod_func
+
+      return if recv_ty == :top #OK
+      recv_ty.each_child_global do |ty|
+        raise ty.inspect if !ty.is_a?(Type::Instance) && !ty.is_a?(Type::Class) && ty != Type.any
+      end
     end
 
     attr_reader :recv_ty, :blk_ty, :mod_func
@@ -129,11 +134,7 @@ module TypeProf
             elems2 = type_params[id]
             if elems2
               if elems != elems2
-                if elems.is_a?(Array) # should be refactored as Cell::Elements
-                  type_params[id] = elems.zip(elems2).map {|elem1, elem2| elem1.union(elem2) }
-                else
-                  type_params[id] = elems.union(elems2)
-                end
+                type_params[id] = elems.union(elems2)
               end
             else
               type_params[id] = elems
@@ -151,6 +152,8 @@ module TypeProf
       tys.each do |ty|
         raise "nil cannot be pushed to the stack" if ty.nil?
         ty.each_child do |ty|
+          raise if ty.is_a?(Type::Var)
+          #raise if ty.is_a?(Type::Instance) && ty.klass.type_params.size > 1
           raise "Array cannot be pushed to the stack" if ty.is_a?(Type::Array)
           raise "Hash cannot be pushed to the stack" if ty.is_a?(Type::Hash)
         end
@@ -293,20 +296,11 @@ module TypeProf
       attr_reader :kind, :superclass, :modules, :consts, :methods, :ivars, :cvars, :absolute_path
       attr_accessor :name, :klass_obj
 
-      def include_module(mod, absolute_path)
+      def include_module(mod, singleton, absolute_path)
         # XXX: need to check if mod is already included by the ancestors?
-        absolute_paths = @modules[false][mod]
+        absolute_paths = @modules[singleton][mod]
         unless absolute_paths
-          @modules[false][mod] = absolute_paths = Utils::MutableSet.new
-        end
-        absolute_paths << absolute_path
-      end
-
-      def extend_module(mod, absolute_path)
-        # XXX: need to check if mod is already included by the ancestors?
-        absolute_paths = @modules[true][mod]
-        unless absolute_paths
-          @modules[true][mod] = absolute_paths = Utils::MutableSet.new
+          @modules[singleton][mod] = absolute_paths = Utils::MutableSet.new
         end
         absolute_paths << absolute_path
       end
@@ -353,7 +347,7 @@ module TypeProf
       end
     end
 
-    def include_module(including_mod, included_mod, absolute_path)
+    def include_module(including_mod, included_mod, singleton, absolute_path)
       return if included_mod == Type.any
 
       including_mod = @class_defs[including_mod.idx]
@@ -361,7 +355,7 @@ module TypeProf
         if included_mod.is_a?(Type::Class)
           included_mod = @class_defs[included_mod.idx]
           if included_mod && included_mod.kind == :module
-            including_mod.include_module(included_mod, absolute_path)
+            including_mod.include_module(included_mod, singleton, absolute_path)
           else
             warn "including something that is not a module"
           end
@@ -369,20 +363,6 @@ module TypeProf
       end
     end
 
-    def extend_module(extending_mod, extended_mod, absolute_path)
-      extending_mod = @class_defs[extending_mod.idx]
-      extended_mod.each_child do |extended_mod|
-        if extended_mod.is_a?(Type::Class)
-          extended_mod = @class_defs[extended_mod.idx]
-          if extended_mod && extended_mod.kind == :module
-            extending_mod.extend_module(extended_mod, absolute_path)
-          else
-            warn "extending something that is not a module"
-          end
-        end
-      end
-    end
-
     def cbase_path(cbase)
       cbase && cbase.idx != 1 ? @class_defs[cbase.idx].name : []
     end
@@ -572,9 +552,7 @@ module TypeProf
 
       ret_ty = @return_values[callee_ctx] ||= Type.bot
       if ret_ty != Type.bot
-        @callsites[callee_ctx].each do |caller_ep, ctn|
-          ctn[ret_ty, caller_ep, @return_envs[caller_ep]]
-        end
+        ctn[ret_ty, caller_ep, @return_envs[caller_ep]]
       end
     end
 
@@ -632,7 +610,7 @@ module TypeProf
         entry = @tbl[site] ||= Entry.new(!ep, {}, Type.bot, Utils::MutableSet.new)
         if ep
           if entry.rbs_declared
-            if !entry.type.consistent?(ty, {})
+            unless Type.match?(ty, entry.type)
               scratch.warn(ep, "inconsistent assignment to RBS-declared global variable")
               return
             end
@@ -651,6 +629,7 @@ module TypeProf
     end
 
     def get_ivar(recv)
+      recv = recv.base_type while recv.respond_to?(:base_type)
       case recv
       when Type::Class
         [@class_defs[recv.idx], true]
@@ -884,26 +863,41 @@ module TypeProf
     def pend_method_execution(iseq, meth, recv, mid, cref)
       ctx = Context.new(iseq, cref, mid)
       ep = ExecutionPoint.new(ctx, 0, nil)
-      locals = [Type.any] * iseq.locals.size
-
-      keyword = iseq.fargs_format[:keyword]
+      locals = [Type.nil] * iseq.locals.size
+
+      fargs_format = iseq.fargs_format
+      lead_num = fargs_format[:lead_num] || 0
+      post_num = fargs_format[:post_num] || 0
+      post_index = fargs_format[:post_start]
+      rest_index = fargs_format[:rest_start]
+      keyword = fargs_format[:keyword]
+      kw_index = fargs_format[:kwbits] - keyword.size if keyword
+      kwrest_index = fargs_format[:kwrest]
+      block_index = fargs_format[:block_start]
+      opt = fargs_format[:opt] || [0]
+
+      (lead_num + opt.size - 1).times {|i| locals[i] = Type.any }
+      post_num.times {|i| locals[i + post_index] = Type.any } if post_index
+      locals[rest_index] = Type.any if rest_index
       if keyword
-        kw_start = iseq.fargs_format[:kwbits]
-        kw_start -= iseq.fargs_format[:keyword].size if kw_start
         keyword.each_with_index do |kw, i|
           case
           when kw.is_a?(Symbol) # required keyword
+            locals[kw_index + i] = Type.any
           when kw.size == 2 # optional keyword (default value is a literal)
             _key, default_ty = *kw
             default_ty = Type.guess_literal_type(default_ty)
-            default_ty = default_ty.type if default_ty.is_a?(Type::Literal)
-            locals[kw_start + i] = default_ty.union(Type.any)
+            default_ty = default_ty.base_type if default_ty.is_a?(Type::Literal)
+            locals[kw_index + i] = default_ty.union(Type.any)
           else # optional keyword (default value is an expression)
+            locals[kw_index + i] = Type.any
           end
         end
       end
+      locals[kwrest_index] = Type.any if kwrest_index
+      locals[block_index] = Type.nil if block_index
 
-      env = Env.new(StaticEnv.new(recv, Type.any, false), locals, [], Utils::HashWrapper.new({}))
+      env = Env.new(StaticEnv.new(recv, Type.nil, false), locals, [], Utils::HashWrapper.new({}))
 
       @pending_execution[iseq] ||= [:method, [meth, ep, env]]
     end
@@ -986,7 +980,7 @@ module TypeProf
             when kw.size == 2 # optional keyword (default value is a literal)
               key, default_ty = *kw
               default_ty = Type.guess_literal_type(default_ty)
-              default_ty = default_ty.type if default_ty.is_a?(Type::Literal)
+              default_ty = default_ty.base_type if default_ty.is_a?(Type::Literal)
               req = false
             else # optional keyword (default value is an expression)
               key, = kw
@@ -1029,7 +1023,17 @@ module TypeProf
         ty = Type::Literal.new(str, Type::Instance.new(Type::Builtin[:str]))
         env = env.push(ty)
       when :putself
-        env, ty = localize_type(env.static_env.recv_ty, env, ep)
+        ty = env.static_env.recv_ty
+        if ty.is_a?(Type::Instance)
+          klass = ty.klass
+          if klass.type_params.size >= 1
+            ty = Type::ContainerType.create_empty_instance(klass)
+            env, ty = localize_type(ty, env, ep, AllocationSite.new(ep))
+          else
+            ty = Type::Instance.new(klass)
+          end
+          env, ty = localize_type(ty, env, ep)
+        end
         env = env.push(ty)
       when :newarray, :newarraykwsplat
         len, = operands
@@ -1700,15 +1704,27 @@ module TypeProf
         end
 
       when :checktype
-        type, = operands
-        raise NotImplementedError if type != 5 # T_STRING
-        # XXX: is_a?
-        env, (val,) = env.pop(1)
-        res = globalize_type(val, env, ep) == Type::Instance.new(Type::Builtin[:str])
-        if res
-          ty = Type::Instance.new(Type::Builtin[:true])
+        kind, = operands
+        case kind
+        when 5 then klass = :str  # T_STRING
+        when 7 then klass = :ary  # T_ARRAY
+        when 8 then klass = :hash # T_HASH
         else
-          ty = Type::Instance.new(Type::Builtin[:false])
+          raise NotImplementedError
+        end
+        env, (val,) = env.pop(1)
+        ty = Type.bot
+        val.each_child do |val|
+        #globalize_type(val, env, ep).each_child_global do |val|
+          val = val.base_type while val.respond_to?(:base_type)
+          case val
+          when Type::Instance.new(Type::Builtin[klass])
+            ty = ty.union(Type::Instance.new(Type::Builtin[:true]))
+          when Type.any
+            ty = Type.bool
+          else
+            ty = ty.union(Type::Instance.new(Type::Builtin[:false]))
+          end
         end
         env = env.push(ty)
       else
@@ -1857,7 +1873,7 @@ module TypeProf
           kw_tys = ty.elems.to_keywords
         when Type::Union
           hash_elems = nil
-          ty.elems.each do |(container_kind, base_type), elems|
+          ty.elems&.each do |(container_kind, base_type), elems|
             if container_kind == Type::Hash
               hash_elems = hash_elems ? hash_elems.union(elems) : elems
             end
@@ -1946,7 +1962,7 @@ module TypeProf
             end
           end
 
-          @block_to_ctx[blk.block_body].each do |blk_ctx|
+          @block_to_ctx[blk.block_body]&.each do |blk_ctx|
             ret_ty = ret_ty.union(@return_values[blk_ctx]) if @return_values[blk_ctx]
           end
         end

data/lib/typeprof/arguments.rb

@@ -25,7 +25,7 @@ module TypeProf
       self
     end
 
-    def consistent_with_method_signature?(msig, subst)
+    def consistent_with_method_signature?(msig)
       aargs = @lead_tys.dup
 
       # aargs: lead_tys, rest_ty
@@ -36,53 +36,61 @@ module TypeProf
         (lower_bound..upper_bound).each do |n|
           # BUG: @rest_ty is an Array, so need to squash
           tmp_aargs = ActualArguments.new(@lead_tys + [@rest_ty] * n, nil, @kw_tys, @blk_ty)
-          if tmp_aargs.consistent_with_method_signature?(msig, subst) # XXX: wrong subst handling in the loop!
-            return true
-          end
+          subst = tmp_aargs.consistent_with_method_signature?(msig) # XXX: wrong subst handling in the loop!
+          return subst if subst
         end
-        return false
+        return nil
       end
 
+      subst = {}
       if msig.rest_ty
-        return false if aargs.size < msig.lead_tys.size + msig.post_tys.size
+        return nil if aargs.size < msig.lead_tys.size + msig.post_tys.size
         aargs.shift(msig.lead_tys.size).zip(msig.lead_tys) do |aarg, farg|
-          return false unless aarg.consistent?(farg, subst)
+          return nil unless subst2 = Type.match?(aarg, farg)
+          subst = Type.merge_substitution(subst, subst2)
         end
         aargs.pop(msig.post_tys.size).zip(msig.post_tys) do |aarg, farg|
-          return false unless aarg.consistent?(farg, subst)
+          return nil unless subst2 = Type.match?(aarg, farg)
+          subst = Type.merge_substitution(subst, subst2)
         end
         msig.opt_tys.each do |farg|
           aarg = aargs.shift
-          return false unless aarg.consistent?(farg, subst)
+          return nil unless subst2 = Type.match?(aarg, farg)
+          subst = Type.merge_substitution(subst, subst2)
         end
         aargs.each do |aarg|
-          return false unless aarg.consistent?(msig.rest_ty, subst)
+          return nil unless subst2 = Type.match?(aarg, msig.rest_ty)
+          subst = Type.merge_substitution(subst, subst2)
         end
       else
-        return false if aargs.size < msig.lead_tys.size + msig.post_tys.size
-        return false if aargs.size > msig.lead_tys.size + msig.post_tys.size + msig.opt_tys.size
+        return nil if aargs.size < msig.lead_tys.size + msig.post_tys.size
+        return nil if aargs.size > msig.lead_tys.size + msig.post_tys.size + msig.opt_tys.size
         aargs.shift(msig.lead_tys.size).zip(msig.lead_tys) do |aarg, farg|
-          return false unless aarg.consistent?(farg, subst)
+          return nil unless subst2 = Type.match?(aarg, farg)
+          subst = Type.merge_substitution(subst, subst2)
         end
         aargs.pop(msig.post_tys.size).zip(msig.post_tys) do |aarg, farg|
-          return false unless aarg.consistent?(farg, subst)
+          return nil unless subst2 = Type.match?(aarg, farg)
+          subst = Type.merge_substitution(subst, subst2)
         end
         aargs.zip(msig.opt_tys) do |aarg, farg|
-          return false unless aarg.consistent?(farg, subst)
+          return nil unless subst2 = Type.match?(aarg, farg)
+          subst = Type.merge_substitution(subst, subst2)
         end
       end
       # XXX: msig.keyword_tys
 
       case msig.blk_ty
       when Type::Proc
-        return false if @blk_ty == Type.nil
+        return nil if @blk_ty == Type.nil
       when Type.nil
-        return false if @blk_ty != Type.nil
+        return nil if @blk_ty != Type.nil
       when Type::Any
       else
         raise "unknown type of formal block signature"
       end
-      true
+
+      subst
     end
 
     def argument_error(given, exp_lower, exp_upper)
@@ -345,7 +353,7 @@ module TypeProf
           when kw.size == 2 # optional keyword (default value is a literal)
             key, default_ty = *kw
             default_ty = Type.guess_literal_type(default_ty)
-            default_ty = default_ty.type if default_ty.is_a?(Type::Literal)
+            default_ty = default_ty.base_type if default_ty.is_a?(Type::Literal)
             req = false
           else # optional keyword (default value is an expression)
             key, = kw

data/lib/typeprof/block.rb

@@ -85,10 +85,13 @@ module TypeProf
     end
 
     def do_call(aargs, caller_ep, caller_env, scratch, replace_recv_ty:, &ctn)
-      subst = { Type::Var.new(:self) => caller_env.static_env.recv_ty } # XXX: support other type variables
-      unless aargs.consistent_with_method_signature?(@msig, subst)
+      aargs = scratch.globalize_type(aargs, caller_env, caller_ep)
+      subst = aargs.consistent_with_method_signature?(@msig)
+      unless subst
         scratch.warn(caller_ep, "The arguments is not compatibile to RBS block")
       end
+      # check?
+      #subst = { Type::Var.new(:self) => caller_env.static_env.recv_ty }
       # XXX: Update type vars
       ctn[@ret_ty, caller_ep, caller_env]
     end

data/lib/typeprof/builtin.rb

@@ -54,6 +54,10 @@ module TypeProf
       ctn[ret_ty, ep, env]
     end
 
+    def vmcore_raise(recv, mid, aargs, ep, env, scratch, &ctn)
+      # no-op
+    end
+
     def lambda(recv, mid, aargs, ep, env, scratch, &ctn)
       ctn[aargs.blk_ty, ep, env]
     end
@@ -63,10 +67,11 @@ module TypeProf
     end
 
     def object_s_new(recv, mid, aargs, ep, env, scratch, &ctn)
-      ty = Type::Instance.new(recv)
       if recv.type_params.size >= 1
-        ty = Type::Cell.new(Type::Cell::Elements.new([Type.bot] * recv.type_params.size), ty)
+        ty = Type::ContainerType.create_empty_instance(recv)
         env, ty = scratch.localize_type(ty, env, ep, AllocationSite.new(ep).add_id(:object_s_new))
+      else
+        ty = Type::Instance.new(recv)
       end
       meths = scratch.get_method(recv, false, :initialize)
       meths.flat_map do |meth|
@@ -149,7 +154,11 @@ module TypeProf
 
     def module_include(recv, mid, aargs, ep, env, scratch, &ctn)
       arg = aargs.lead_tys[0]
-      scratch.include_module(recv, arg, ep.ctx.iseq.absolute_path)
+      arg.each_child do |arg|
+        if arg.is_a?(Type::Class)
+          scratch.include_module(recv, arg, false, ep.ctx.iseq.absolute_path)
+        end
+      end
       ctn[recv, ep, env]
     end
 
@@ -157,7 +166,7 @@ module TypeProf
       arg = aargs.lead_tys[0]
       arg.each_child do |arg|
         if arg.is_a?(Type::Class)
-          scratch.extend_module(recv, arg, ep.ctx.iseq.absolute_path)
+          scratch.include_module(recv, arg, true, ep.ctx.iseq.absolute_path)
         end
       end
       ctn[recv, ep, env]
@@ -520,6 +529,7 @@ module TypeProf
       scratch.set_custom_method(klass_vmcore, :"core#set_method_alias", Builtin.method(:vmcore_set_method_alias))
       scratch.set_custom_method(klass_vmcore, :"core#undef_method", Builtin.method(:vmcore_undef_method))
       scratch.set_custom_method(klass_vmcore, :"core#hash_merge_kwd", Builtin.method(:vmcore_hash_merge_kwd))
+      scratch.set_custom_method(klass_vmcore, :"core#raise", Builtin.method(:vmcore_raise))
       scratch.set_custom_method(klass_vmcore, :lambda, Builtin.method(:lambda))
       scratch.set_singleton_custom_method(klass_obj, :"new", Builtin.method(:object_s_new))
       scratch.set_singleton_custom_method(klass_obj, :"attr_accessor", Builtin.method(:module_attr_accessor))