typeprof 0.4.2 → 0.5.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d2ffa092b1a33661649a9a3b48347d78baf5d9bac0ba4020f72a122442d4d287
-  data.tar.gz: fbe985ca3547bd831564f5921f38edf65160c86133bb0219596aaa4e5962066a
+  metadata.gz: 2d60066fe3965ec65f9885e311f856277d0e41330478489c026fdf6b387ba2ba
+  data.tar.gz: 963b66fe97d98207d72645011bcd012368937ded76278d92a4b677b961c92cdc
 SHA512:
-  metadata.gz: b260426c710befa65825fc41998643ced8ef3b43d4edc16b5eb9a2f00cbaf865c832f80ee3443c6a8e9f725e5def2d6bd47a1109e97dffaab8d17771035ae08a
-  data.tar.gz: 47cf9f339601864c16464859d92aa9b904e51c471da84c2f2997519947edbc9c647b1762129cc0d677264fe0c0372de56acf04e98968a7b6e1c372d43af8a543
+  metadata.gz: a40e89e05c1680480eb66798863ab99a4b38b3faaacdc471a6cdd45dfc1f897efcc8f613800ef28e5bc722c3504dec510ca943435873b6cb765a27f1bb073425
+  data.tar.gz: 94dddf2c3e465ee19093ce571d50440293118b07ab7c90203aa5ccb40c4f9eb9afe1059eff045c965006affa8f0d66d141be2064feddf9a2b1f8384f8cadae64

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.1)
-      rbs (>= 0.16.0)
+    typeprof (0.5.4)
+      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
@@ -249,6 +252,8 @@ module TypeProf
       @rbs_reader = RBSReader.new
 
       @terminated = false
+
+      @anonymous_struct_gen_id = 0
     end
 
     attr_reader :return_envs, :loaded_features, :rbs_reader
@@ -293,20 +298,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)
-        # XXX: need to check if mod is already included by the ancestors?
-        absolute_paths = @modules[false][mod]
-        unless absolute_paths
-          @modules[false][mod] = absolute_paths = Utils::MutableSet.new
-        end
-        absolute_paths << absolute_path
-      end
-
-      def extend_module(mod, absolute_path)
+      def include_module(mod, singleton, absolute_path)
         # XXX: need to check if mod is already included by the ancestors?
-        absolute_paths = @modules[true][mod]
+        absolute_paths = @modules[singleton][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 +349,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 +357,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 +365,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
@@ -417,8 +399,9 @@ module TypeProf
 
       idx = @class_defs.size
       superclass = Type::Builtin[:struct]
-      @class_defs[idx] = ClassDef.new(:class, ["(Anonymous Struct)"], superclass.idx, ep.ctx.iseq.absolute_path)
-      klass = Type::Class.new(:class, idx, [], superclass, "(Anonymous Struct)")
+      name = "AnonymousStruct_generated_#{ @anonymous_struct_gen_id += 1 }"
+      @class_defs[idx] = ClassDef.new(:class, [name], superclass.idx, ep.ctx.iseq.absolute_path)
+      klass = Type::Class.new(:class, idx, [], superclass, name)
       @class_defs[idx].klass_obj = klass
 
       @struct_defs[ep] = klass
@@ -572,9 +555,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 +613,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 +632,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 +866,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 +983,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 +1026,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
@@ -1128,35 +1135,29 @@ module TypeProf
           else
             if existing_klass != Type.any
               error(ep, "the class \"#{ id }\" is #{ existing_klass.screen_name(self) }")
-              id = :"#{ id }(dummy)"
             end
-            existing_klass = get_constant(cbase, id) # TODO: multiple return values
-            if existing_klass != Type.any
-              klass = existing_klass
-            else
-              if type == :class
-                if superclass.is_a?(Type::Class)
-                  # okay
-                elsif superclass == Type.any
-                  warn(ep, "superclass is any; Object is used instead")
-                  superclass = Type::Builtin[:obj]
-                elsif superclass == Type.nil
-                  superclass = Type::Builtin[:obj]
-                elsif superclass.is_a?(Type::Instance)
-                  warn(ep, "superclass is an instance; Object is used instead")
-                  superclass = Type::Builtin[:obj]
-                else
-                  warn(ep, "superclass is not a class; Object is used instead")
-                  superclass = Type::Builtin[:obj]
-                end
-              else # module
-                superclass = nil
-              end
-              if cbase == Type.any
-                klass = Type.any
+            if type == :class
+              if superclass.is_a?(Type::Class)
+                # okay
+              elsif superclass == Type.any
+                warn(ep, "superclass is any; Object is used instead")
+                superclass = Type::Builtin[:obj]
+              elsif superclass == Type.nil
+                superclass = Type::Builtin[:obj]
+              elsif superclass.is_a?(Type::Instance)
+                warn(ep, "superclass is an instance; Object is used instead")
+                superclass = Type::Builtin[:obj]
               else
-                klass = new_class(cbase, id, [], superclass, ep.ctx.iseq.absolute_path)
+                warn(ep, "superclass is not a class; Object is used instead")
+                superclass = Type::Builtin[:obj]
               end
+            else # module
+              superclass = nil
+            end
+            if cbase == Type.any
+              klass = Type.any
+            else
+              klass = new_class(cbase, id, [], superclass, ep.ctx.iseq.absolute_path)
             end
           end
           singleton = false
@@ -1700,15 +1701,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
@@ -1946,7 +1959,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