typeprof 0.20.2 → 0.21.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bacf4fa5ea4b9d22be05ade768e45b4a3e86f8845e6e470775d9c9333e72e5ad
-  data.tar.gz: 186ed39f8e38d58bf710cea41942eaff66bc9ca505560e67a6f43d7ce6790896
+  metadata.gz: dafe7189434a08afb147b33a67d030e17f2dd93f7495b3b42d220375e028a8c4
+  data.tar.gz: '05090ed2b4df798245b2f7e62912e19e8c92176b7eab72bee8d1c6759a85e105'
 SHA512:
-  metadata.gz: 3f67fb359672f245991f71b50475ff6a472f2db67ab8c3e508a4bea7ff89155a407b8de9747e64444f2c79f78311305018951eeae896ddab594b8ceca864b67f
-  data.tar.gz: ade3c4b52badc09023a669ea4fc1d10d66dc80ae35f4e65c8a92cb25d851701d6d79f135589c99f24b650da8fc863761911c450b5cb660ea93b6562ac18e6881
+  metadata.gz: 934bddb52e1f5ca98df3e3534b400471da72efbf4a0648c9c1c162535cdf1023fff7fdc6620205934a75142401aadba0f739138c7bd96e7522a677d8b5100b63
+  data.tar.gz: 9c047caa1cffa7ffe97f73d17554c271582b28082f949c48fd234950138bd0c9dfcd8e70c4b1493c868ef4dbe75355a8f92dad7100b7eeafb8ff55367ba54e29

data/Gemfile.lock

@@ -1,17 +1,17 @@
 PATH
   remote: .
   specs:
-    typeprof (0.20.2)
-      rbs (>= 1.6.2)
+    typeprof (0.21.0)
+      rbs (>= 1.8.1)
 
 GEM
   remote: https://rubygems.org/
   specs:
     coverage-helpers (1.0.0)
     docile (1.4.0)
-    power_assert (2.0.0)
+    power_assert (2.0.1)
     rake (13.0.1)
-    rbs (1.6.2)
+    rbs (1.8.1)
     simplecov (0.21.2)
       docile (~> 1.1)
       simplecov-html (~> 0.11)
@@ -19,7 +19,7 @@ GEM
     simplecov-html (0.12.3)
     simplecov_json_formatter (0.1.3)
     stackprof (0.2.17)
-    test-unit (3.4.4)
+    test-unit (3.5.3)
       power_assert
 
 PLATFORMS

data/lib/typeprof/analyzer.rb

@@ -345,7 +345,7 @@ module TypeProf
     attr_reader :class_defs
 
     class ClassDef # or ModuleDef
-      def initialize(kind, name, absolute_path)
+      def initialize(kind, name, absolute_path, superclass)
         raise unless name.is_a?(Array)
         @kind = kind
         @modules = {
@@ -359,10 +359,11 @@ module TypeProf
         @cvars = VarTable.new
         @absolute_path = absolute_path
         @namespace = nil
+        @superclass = superclass
         @subclasses = []
       end
 
-      attr_reader :kind, :modules, :methods, :ivars, :cvars, :absolute_path, :subclasses
+      attr_reader :kind, :modules, :methods, :ivars, :cvars, :absolute_path, :superclass, :subclasses
       attr_accessor :name, :klass_obj
 
       def mix_module(kind, mod, type_args, singleton, absolute_path)
@@ -446,14 +447,22 @@ module TypeProf
         end
       end
 
-      def check_typed_method(mid, singleton)
+      def check_typed(mid, singleton, klass)
         set = @methods[[singleton, mid]]
         return nil unless set
-        set = set.select {|mdef| mdef.is_a?(TypedMethodDef) }
+        set = set.select {|mdef| mdef.is_a?(klass) }
         return nil if set.empty?
         return set
       end
 
+      def check_typed_method(mid, singleton)
+        check_typed(mid, singleton, TypedMethodDef)
+      end
+
+      def check_typed_attr(mid, singleton)
+        check_typed(mid, singleton, TypedAttrMethodDef)
+      end
+
       def add_method(mid, singleton, mdef)
         @methods[[singleton, mid]] ||= Utils::MutableSet.new
         @methods[[singleton, mid]] << mdef
@@ -494,8 +503,9 @@ module TypeProf
       show_name = cbase_path(cbase) + [name]
       idx = @class_defs.size
       if superclass
-        @class_defs[idx] = ClassDef.new(:class, show_name, def_ep&.absolute_path)
-        @class_defs[superclass.idx].subclasses << idx unless superclass == :__root__
+        superclass_def = @class_defs[superclass.idx] unless superclass == :__root__
+        @class_defs[idx] = ClassDef.new(:class, show_name, def_ep&.absolute_path, superclass_def)
+        superclass_def.subclasses << idx if superclass_def
         klass = Type::Class.new(:class, idx, type_params, superclass, show_name)
         @class_defs[idx].klass_obj = klass
         cbase ||= klass # for bootstrap
@@ -503,7 +513,7 @@ module TypeProf
         return klass
       else
         # module
-        @class_defs[idx] = ClassDef.new(:module, show_name, def_ep&.absolute_path)
+        @class_defs[idx] = ClassDef.new(:module, show_name, def_ep&.absolute_path, nil)
         mod = Type::Class.new(:module, idx, type_params, nil, show_name)
         @class_defs[idx].klass_obj = mod
         add_constant(cbase, name, mod, def_ep)
@@ -521,7 +531,8 @@ module TypeProf
       idx = @class_defs.size
       superclass = Type::Builtin[:struct]
       name = "AnonymousStruct_generated_#{ @anonymous_struct_gen_id += 1 }"
-      @class_defs[idx] = ClassDef.new(:class, [name], ep.ctx.iseq.absolute_path)
+      # Should we pass a superclass here?
+      @class_defs[idx] = ClassDef.new(:class, [name], ep.ctx.iseq.absolute_path, nil)
       #@class_defs[superclass.idx].subclasses << idx # needed?
       klass = Type::Class.new(:class, idx, [], superclass, name)
       add_superclass_type_args!(klass, [Type.any])
@@ -701,6 +712,10 @@ module TypeProf
       @class_defs[klass.idx].check_typed_method(mid, singleton)
     end
 
+    def check_typed_attr(klass, mid, singleton)
+      @class_defs[klass.idx].check_typed_attr(mid, singleton)
+    end
+
     def add_method(klass, mid, singleton, mdef)
       @class_defs[klass.idx].add_method(mid, singleton, mdef)
       mdef
@@ -713,13 +728,26 @@ module TypeProf
 
     def add_attr_method(klass, mid, ivar, kind, pub_meth, ep)
       if kind == :reader || kind == :accessor
-        add_method(klass, mid, false, AttrMethodDef.new(ivar, :reader, pub_meth, ep))
+        typed_mdef = check_typed_attr(klass, mid, ep.ctx.cref.singleton)
+        unless typed_mdef
+          add_method(klass, mid, false, ExecutedAttrMethodDef.new(ivar, :reader, pub_meth, ep))
+        end
       end
       if kind == :writer || kind == :accessor
-        add_method(klass, :"#{ mid }=", false, AttrMethodDef.new(ivar, :writer, pub_meth, ep))
+        mid = :"#{ mid }="
+        typed_mdef = check_typed_attr(klass, mid, ep.ctx.cref.singleton)
+        unless typed_mdef
+          add_method(klass, mid, false, ExecutedAttrMethodDef.new(ivar, :writer, pub_meth, ep))
+        end
       end
     end
 
+    def add_typed_attr_method(klass, mdef)
+      name = mdef.ivar[1..-1]
+      name = mdef.kind == :writer ? :"#{ name }=" : name.to_sym
+      add_method(klass, name, false, mdef)
+    end
+
     def add_iseq_method(klass, mid, iseq, cref, outer_ep, pub_meth)
       add_method(klass, mid, false, ISeqMethodDef.new(iseq, cref, outer_ep, pub_meth))
     end
@@ -848,7 +876,7 @@ module TypeProf
         end
         entry.type = entry.type.union(ty)
         entry.read_continuations.each do |read_ep, ctn|
-          ctn[ty, read_ep, [ep]]
+          ctn[ty, read_ep, ep ? [ep] : []]
         end
       end
 
@@ -1396,6 +1424,9 @@ module TypeProf
       when :tostring, :anytostring
         env, (_ty1, _ty2,) = env.pop(2)
         env = env.push(Type::Instance.new(Type::Builtin[:str]))
+      when :objtostring
+        env, (_ty1,) = env.pop(1)
+        env = env.push(Type::Instance.new(Type::Builtin[:str]))
       when :freezestring
         # do nothing
       when :toregexp
@@ -1418,7 +1449,16 @@ module TypeProf
         cref = ep.ctx.cref
         recv.each_child do |recv|
           if recv.is_a?(Type::Class)
-            meth = add_singleton_iseq_method(recv, mid, iseq, cref, nil, env.static_env.pub_meth)
+            typed_mdef = check_typed_method(recv, mid, true)
+            if typed_mdef
+              mdef = ISeqMethodDef.new(iseq, cref, nil, env.static_env.pub_meth)
+              typed_mdef.each do |typed_mdef|
+                typed_mdef.do_match_iseq_mdef(mdef, recv, mid, env, ep, self)
+              end
+            else
+              meth = add_singleton_iseq_method(recv, mid, iseq, cref, nil, env.static_env.pub_meth)
+            end
+
             pend_method_execution(iseq, meth, recv, mid, ep.ctx.cref, nil)
           else
             recv = Type.any # XXX: what to do?

data/lib/typeprof/block.rb

@@ -97,7 +97,8 @@ module TypeProf
       # check?
       #subst = { Type::Var.new(:self) => caller_env.static_env.recv_ty }
       # XXX: Update type vars
-      ctn[@ret_ty, caller_ep, caller_env]
+      ret_ty = @ret_ty.remove_type_vars
+      ctn[ret_ty, caller_ep, caller_env]
     end
   end
 

data/lib/typeprof/container-type.rb

@@ -227,8 +227,9 @@ module TypeProf
 
       def screen_name(scratch)
         str = @elems.screen_name(scratch)
-        if str.start_with?("*")
-          str = @base_type.screen_name(scratch) + str[1..]
+        if str =~ /\A\*\[(.*)\]\z/
+          str = @base_type.klass.type_params.map {|var_name,| var_name == :Elem ? $1 : "untyped" }.join(", ")
+          str = "#{ @base_type.screen_name(scratch) }[#{ str }]"
         end
         str
       end

data/lib/typeprof/export.rb

@@ -163,8 +163,7 @@ module TypeProf
             visibilities[key] ||= mdef.pub_meth
             source_locations[key] ||= mdef.def_ep&.source_location
             methods[key] = orig_name
-          when AttrMethodDef
-            next if !mdef.def_ep
+          when ExecutedAttrMethodDef
             absolute_path = mdef.def_ep.ctx.iseq.absolute_path
             next if !absolute_path || Config.current.check_dir_filter(absolute_path) == :exclude
             mid = mid.to_s[0..-2].to_sym if mid.to_s.end_with?("=")
@@ -191,14 +190,46 @@ module TypeProf
               visibilities[key] ||= mdef.pub_meth
               source_locations[key] ||= mdef.iseq&.source_location(0)
             end
+          when TypedAttrMethodDef
+            if mdef.rbs_source
+              mid = mid.to_s[0..-2].to_sym if mid.to_s.end_with?("=")
+              method_name = mid
+              method_name = [method_name, :"@#{ mid }" != mdef.ivar]
+              key = [:rbs_attr, method_name]
+              visibilities[key] ||= mdef.pub_meth
+              if methods[key]
+                if methods[key][0] != mdef.kind
+                  methods[key][0] = :accessor
+                end
+              else
+                entry = ivars[[singleton, mdef.ivar]]
+                ty = entry ? entry.type : Type.any
+                methods[key] = [mdef.kind, ty.screen_name(@scratch), ty.include_untyped?(@scratch)]
+              end
+            end
           end
         end
       end
 
+      superclass_ivars = {}
+      while (superclass_def = (superclass_def || class_def).superclass)
+        superclass_ivars.merge!(superclass_def.ivars.dump)
+      end
+
       ivars = ivars.map do |(singleton, var), entry|
         next if entry.absolute_paths.all? {|path| Config.current.check_dir_filter(path) == :exclude }
         ty = entry.type
         next unless var.to_s.start_with?("@")
+
+        if (_, existing = superclass_ivars.find {|((s, v), _)| s == singleton && v == var })
+          existing_types = existing.type.is_a?(Type::Union) ? existing.type.types : [existing.type]
+          entry_types = entry.type.is_a?(Type::Union) ? entry.type.types : [entry.type]
+          if entry_types.all? { |t| existing_types.include?(t) }
+            # This type is a subset of the parent type
+            next
+          end
+        end
+
         var = "self.#{ var }" if singleton
         next if methods[[:attr, [singleton ? "self.#{ var.to_s[1..] }" : var.to_s[1..].to_sym, false]]]
         next if entry.rbs_declared
@@ -302,7 +333,7 @@ module TypeProf
             visibilities[key] ||= mdef.pub_meth
             source_locations[key] ||= [mdef.def_ep&.source_location]
             methods[key] = orig_name
-          when AttrMethodDef
+          when ExecutedAttrMethodDef
             next if !mdef.def_ep
             absolute_path = mdef.def_ep.ctx.iseq.absolute_path
             next if !absolute_path || Config.current.check_dir_filter(absolute_path) == :exclude
@@ -383,7 +414,7 @@ module TypeProf
           source_location, rbs_code_range = class_data.source_locations[key]
           type, (method_name, hidden) = key
           case type
-          when :attr
+          when :attr, :rbs_attr
             kind, ty, untyped = *arg
             line = "attr_#{ kind } #{ method_name }#{ hidden ? "()" : "" }: #{ ty }"
           when :rbs
@@ -522,11 +553,15 @@ module TypeProf
         end
         type, (method_name, hidden) = key
         case type
+        when :rbs_attr
+          kind, ty, untyped = *arg
+          lines << (indent + "# attr_#{ kind } #{ method_name }#{ hidden ? "()" : "" }: #{ ty }")
         when :attr
           kind, ty, untyped = *arg
           exclude = Config.current.options[:exclude_untyped] && untyped ? "#" : " " # XXX
           lines << (indent + "#{ exclude } attr_#{ kind } #{ method_name }#{ hidden ? "()" : "" }: #{ ty }")
         when :rbs
+          arg = arg.map { |a| a.split("\n").join("\n" + indent + "#" + " " * (method_name.size + 5)) }
           sigs = arg.sort.join("\n" + indent + "#" + " " * (method_name.size + 5) + "| ")
           lines << (indent + "# def #{ method_name }: #{ sigs }")
         when :iseq

data/lib/typeprof/import.rb

@@ -158,7 +158,10 @@ module TypeProf
         decls.each do |decl|
           decl = decl.decl
 
-          type_params2 = decl.type_params.params.map {|param| [param.name, param.variance] }
+          type_params2 = decl.type_params
+          # A hack to deal with the imcompatibility between rbs 1.8 and 2.0
+          type_params2 = type_params2.params if type_params2.respond_to?(:params)
+          type_params2 = type_params2.map {|param| [param.name, param.variance] }
           raise "inconsistent type parameter declaration" if type_params && type_params != type_params2
           type_params = type_params2
 
@@ -191,12 +194,15 @@ module TypeProf
             when RBS::AST::Members::AttrReader
               ty = conv_type(member.type)
               attr_methods[[false, member.name]] = attr_method_def(:reader, member.name, ty, visibility)
+              rbs_sources[[false, member.name]] = attr_rbs_source(member)
             when RBS::AST::Members::AttrWriter
               ty = conv_type(member.type)
               attr_methods[[false, member.name]] = attr_method_def(:writer, member.name, ty, visibility)
+              rbs_sources[[false, member.name]] = attr_rbs_source(member)
             when RBS::AST::Members::AttrAccessor
               ty = conv_type(member.type)
               attr_methods[[false, member.name]] = attr_method_def(:accessor, member.name, ty, visibility)
+              rbs_sources[[false, member.name]] = attr_rbs_source(member)
             when RBS::AST::Members::Alias
               # XXX: an alias to attr methods?
               if member.instance?
@@ -394,6 +400,14 @@ module TypeProf
       }
     end
 
+    def attr_rbs_source(member)
+      [
+        member.name.to_s,
+        member.type.location.source,
+        [member.location.name, CodeRange.from_rbs(member.location)],
+      ]
+    end
+
     def conv_block(rbs_block)
       blk = rbs_block.type
 
@@ -604,11 +618,13 @@ module TypeProf
         end
 
         attr_methods.each do |(singleton, method_name), mdef|
-          kind = mdef[:kind]
-          ivar = mdef[:ivar]
+          rbs_source = explicit ? rbs_sources[[singleton, method_name]] : nil
           ty = conv_type(mdef[:ty]).remove_type_vars
-          @scratch.add_attr_method(klass, ivar, :"@#{ ivar }", kind, mdef[:visibility], nil)
-          @scratch.add_ivar_write!(Type::Instance.new(klass), :"@#{ ivar }", ty, nil)
+          mdefs = conv_attr_defs(mdef, rbs_source)
+          mdefs.each do |mdef|
+            @scratch.add_typed_attr_method(klass, mdef)
+          end
+          @scratch.add_ivar_write!(Type::Instance.new(klass), :"@#{ mdef[:ivar] }", ty, nil)
         end
 
         ivars.each do |ivar_name, ty|
@@ -644,6 +660,22 @@ module TypeProf
       TypedMethodDef.new(sig_rets, rbs_source, mdef[:visibility])
     end
 
+    def conv_attr_defs(mdef, rbs_source)
+      ivar = :"@#{ mdef[:ivar] }"
+      kind = mdef[:kind]
+      pub_meth = mdef[:visibility]
+
+      defs = []
+      if kind == :reader || kind == :accessor
+        defs << TypedAttrMethodDef.new(ivar, :reader, pub_meth, rbs_source)
+      end
+      if kind == :writer || kind == :accessor
+        defs << TypedAttrMethodDef.new(ivar, :writer, pub_meth, rbs_source)
+      end
+      raise if defs.empty?
+      defs
+    end
+
     def conv_func(sig_ret)
       #type_params = sig_ret[:type_params] # XXX
       lead_tys = sig_ret[:lead_tys]

data/lib/typeprof/insns-def.rb

@@ -21,6 +21,7 @@ TypeProf::INSN_TABLE = {:nop=>[],
  :putstring=>["VALUE"],
  :concatstrings=>["rb_num_t"],
  :tostring=>[],
+ :objtostring=>[],
  :anytostring=>[],
  :freezestring=>["VALUE"],
  :toregexp=>["rb_num_t", "rb_num_t"],

data/lib/typeprof/iseq.rb

@@ -704,7 +704,7 @@ module TypeProf
         sp += 1
       when :newhashfromarray
         raise NotImplementedError, "newhashfromarray"
-      when :newrange, :tostring, :anytostring
+      when :newrange, :tostring, :objtostring, :anytostring
         sp -= 2
         return nil if sp <= 0
         sp += 1
@@ -753,7 +753,7 @@ module TypeProf
       when :setlocal, :setblockparam
         return # conservative
       when :getinstancevariable, :getclassvariable, :getglobal,
-           :getlocal, :getblockparam, :getblockparamproxy
+           :getlocal, :getblockparam, :getblockparamproxy, :getlocal_checkmatch_branch
         sp += 1
       when :getconstant
         sp -= 2

data/lib/typeprof/method.rb

@@ -67,6 +67,10 @@ module TypeProf
       if rest_start
         # almost ok
       else
+        if msig.rest_ty
+          scratch.error(ep, "RBS says that a rest argument is accepted, but the method definition does not accept one")
+          return
+        end
         if msig.lead_tys.size + msig.post_tys.size < lead_num + post_num
           scratch.error(ep, "RBS says that the arity may be %d, but the method definition requires at least %d arguments" % [msig.lead_tys.size + msig.post_tys.size, lead_num + post_num])
           return
@@ -79,7 +83,6 @@ module TypeProf
 
       lead_num = @iseq.fargs_format[:lead_num] || 0
       post_start = @iseq.fargs_format[:post_start]
-      rest_start = @iseq.fargs_format[:rest_start]
       kw_start = @iseq.fargs_format[:kwbits]
       keyword = @iseq.fargs_format[:keyword]
       kw_start -= keyword.size if kw_start
@@ -175,14 +178,13 @@ module TypeProf
   end
 
   class AttrMethodDef < MethodDef
-    def initialize(ivar, kind, pub_meth, def_ep)
+    def initialize(ivar, kind, pub_meth)
       @ivar = ivar
       @kind = kind # :reader | :writer
       @pub_meth = pub_meth
-      @def_ep = def_ep
     end
 
-    attr_reader :ivar, :kind, :def_ep
+    attr_reader :ivar, :kind
 
     def do_send(recv, mid, aargs, caller_ep, caller_env, scratch, &ctn)
       case @kind
@@ -206,6 +208,25 @@ module TypeProf
     end
   end
 
+  class ExecutedAttrMethodDef < AttrMethodDef
+    def initialize(ivar, kind, pub_meth, def_ep)
+      super(ivar, kind, pub_meth)
+      @def_ep = def_ep
+    end
+
+    attr_reader :def_ep
+  end
+
+  class TypedAttrMethodDef < AttrMethodDef
+    def initialize(ivar, kind, pub_meth, rbs_source)
+      @rbs_source = rbs_source
+
+      super(ivar, kind, pub_meth)
+    end
+
+    attr_reader :rbs_source
+  end
+
   class TypedMethodDef < MethodDef
     def initialize(sig_rets, rbs_source, pub_meth) # sig_rets: Array<[MethodSignature, (return)Type]>
       @sig_rets = sig_rets

data/lib/typeprof/type.rb

@@ -422,22 +422,22 @@ module TypeProf
     end
 
     def self.any
-      @any ||= Any.new
+      Thread.current[:any] ||= Any.new
     end
 
     def self.bot
-      @bot ||= Union.new(Utils::Set[], nil)
+      Thread.current[:bot] ||= Union.new(Utils::Set[], nil)
     end
 
     def self.bool
-      @bool ||= Union.new(Utils::Set[
+      Thread.current[:bool] ||= Union.new(Utils::Set[
         Instance.new(Type::Builtin[:true]),
         Instance.new(Type::Builtin[:false])
       ], nil)
     end
 
     def self.nil
-      @nil ||= Instance.new(Type::Builtin[:nil])
+      Thread.current[:nil] ||= Instance.new(Type::Builtin[:nil])
     end
 
     def self.optional(ty)

data/lib/typeprof/version.rb

@@ -1,3 +1,3 @@
 module TypeProf
-  VERSION = "0.20.2"
+  VERSION = "0.21.1"
 end

data/typeprof.gemspec

@@ -24,11 +24,11 @@ Gem::Specification.new do |spec|
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
   spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
-    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features|smoke|testbed)/}) }
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(doc|test|spec|features|smoke|testbed)/}) }
   end
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_runtime_dependency "rbs", ">= 1.6.2"
+  spec.add_runtime_dependency "rbs", ">= 1.8.1"
 end