typeprof 0.8.0 → 0.9.0

data/lib/typeprof/container-type.rb

@@ -208,10 +208,6 @@ module TypeProf
         @base_type = base_type
       end
 
-      def self.dummy_elements
-        Elements.new([], Type.any)
-      end
-
       attr_reader :elems, :base_type
 
       def inspect
@@ -264,6 +260,10 @@ module TypeProf
           @lead_tys, @rest_ty = lead_tys, rest_ty
         end
 
+        def self.dummy_elements
+          Elements.new([], Type.any)
+        end
+
         attr_reader :lead_tys, :rest_ty
 
         def to_local_type(id, base_ty)
@@ -796,6 +796,7 @@ module TypeProf
     class Local < ContainerType
       def initialize(kind, id, base_type)
         @kind = kind
+        raise if @kind != Cell && @kind != Array && @kind != Hash
         @id = id
         raise unless base_type
         @base_type = base_type

data/lib/typeprof/export.rb

@@ -72,7 +72,7 @@ module TypeProf
       gvars.dump.each do |gvar_name, entry|
         next if entry.type == Type.bot
         s = entry.rbs_declared ? "#" : ""
-        output.puts s + "#{ gvar_name } : #{ entry.type.screen_name(scratch) }"
+        output.puts s + "#{ gvar_name }: #{ entry.type.screen_name(scratch) }"
       end
       output.puts
     end
@@ -269,7 +269,7 @@ module TypeProf
       output.puts indent + "#{ class_data.kind } #{ name }#{ superclass }"
       first = true
       class_data.consts.each do |name, ty|
-        output.puts indent + "  #{ name } : #{ ty }"
+        output.puts indent + "  #{ name }: #{ ty }"
         first = false
       end
       class_data.included_mods.sort.each do |mod|
@@ -281,20 +281,20 @@ module TypeProf
         first = false
       end
       class_data.ivars.each do |var, ty|
-        output.puts indent + "  #{ var } : #{ ty }" unless var.start_with?("_")
+        output.puts indent + "  #{ var }: #{ ty }" unless var.start_with?("_")
         first = false
       end
       class_data.cvars.each do |var, ty|
-        output.puts indent + "  #{ var } : #{ ty }"
+        output.puts indent + "  #{ var }: #{ ty }"
         first = false
       end
       class_data.attr_methods.each do |(method_name, hidden), (kind, ty)|
-        output.puts indent + "  attr_#{ kind } #{ method_name }#{ hidden ? "()" : "" } : #{ ty }"
+        output.puts indent + "  attr_#{ kind } #{ method_name }#{ hidden ? "()" : "" }: #{ ty }"
         first = false
       end
       class_data.explicit_methods.each do |method_name, sigs|
         sigs = sigs.sort.join("\n" + indent + "#" + " " * (method_name.size + 6) + "| ")
-        output.puts indent + "# def #{ method_name } : #{ sigs }"
+        output.puts indent + "# def #{ method_name }: #{ sigs }"
         first = false
       end
       prev_pub_meth = true
@@ -304,7 +304,7 @@ module TypeProf
           output.puts indent + "  #{ pub_meth ? "public" : "private" }"
           prev_pub_meth = pub_meth
         end
-        output.puts indent + "  def #{ method_name } : #{ sigs }"
+        output.puts indent + "  def #{ method_name }: #{ sigs }"
         first = false
       end
       show_class_hierarchy(depth + 1, class_data.inner_classes, output, first)

data/lib/typeprof/import.rb

@@ -26,6 +26,13 @@ module TypeProf
     def load_library(lib)
       loader = RBS::EnvironmentLoader.new(core_root: nil)
       loader.add(library: lib)
+
+      case lib
+      when "yaml"
+        loader.add(library: "pstore")
+        loader.add(library: "dbm")
+      end
+
       new_decls = loader.load(env: @env).map {|decl,| decl }
       RBSReader.load_rbs(@env, new_decls)
     end
@@ -263,8 +270,11 @@ module TypeProf
       end
       return if decl.name == RBS::BuiltinNames::BasicObject.name
       return if decl.name == name
-      @all_env.class_decls[name].decls.each do |decl|
-        each_reference(decl.decl, &blk)
+      decls = @all_env.class_decls[name]
+      if decls
+        decls.decls.each do |decl|
+          each_reference(decl.decl, &blk)
+        end
       end
     end
 
@@ -438,6 +448,8 @@ module TypeProf
         json = scratch.rbs_reader.load_library(feature)
       rescue RBS::EnvironmentLoader::UnknownLibraryError
         return nil
+      rescue RBS::DuplicatedDeclarationError
+        return true
       end
       # need cache?
       Import.new(scratch, json).import

data/lib/typeprof/iseq.rb

@@ -49,10 +49,18 @@ module TypeProf
         insns[i, 0] = [[:_iseq_body_start]]
       end
 
+      # rescue/ensure clauses need to have a dedicated return addresses
+      # because they requires to be virtually called.
+      # So, this preprocess adds "nop" to make a new insn for their return addresses
+      special_labels = {}
+      catch_table.map do |type, iseq, first, last, cont, stack_depth|
+        special_labels[cont] = true if type == :rescue || type == :ensure
+      end
+
       @insns = []
       @linenos = []
 
-      labels = setup_iseq(insns)
+      labels = setup_iseq(insns, special_labels)
 
       # checkmatch->branch
       # send->branch
@@ -60,7 +68,8 @@ module TypeProf
       @catch_table = []
       catch_table.map do |type, iseq, first, last, cont, stack_depth|
         iseq = iseq ? ISeq.new(iseq) : nil
-        entry = [type, iseq, labels[cont], stack_depth]
+        target = labels[special_labels[cont] ? :"#{ cont }_special" : cont]
+        entry = [type, iseq, target, stack_depth]
         labels[first].upto(labels[last]) do |i|
           @catch_table[i] ||= []
           @catch_table[i] << entry
@@ -76,19 +85,26 @@ module TypeProf
       @id <=> other.id
     end
 
-    def setup_iseq(insns)
+    def setup_iseq(insns, special_labels)
       i = 0
       labels = {}
+      ninsns = []
       insns.each do |e|
         if e.is_a?(Symbol) && e.to_s.start_with?("label")
+          if special_labels[e]
+            labels[:"#{ e }_special"] = i
+            ninsns << [:nop]
+            i += 1
+          end
           labels[e] = i
-        elsif e.is_a?(Array)
-          i += 1
+        else
+          i += 1 if e.is_a?(Array)
+          ninsns << e
         end
       end
 
       lineno = 0
-      insns.each do |e|
+      ninsns.each do |e|
         case e
         when Integer # lineno
           lineno = e
@@ -209,7 +225,7 @@ module TypeProf
         end
       end
       send_branch_list.each do |i, j|
-        next if (i + 1 .. j).any? {|i| branch_targets[i] }
+        next if (i + 1 .. j + 1).any? {|i| branch_targets[i] }
         _insn, getlocal_operands = @insns[i]
         _insn, send_operands = @insns[j]
         _insn, branch_operands = @insns[j + 1]

data/lib/typeprof/method.rb

@@ -87,7 +87,7 @@ module TypeProf
       # XXX: need to check .rbs msig and .rb fargs
 
       ctx = Context.new(@iseq, @cref, mid)
-      callee_ep = ExecutionPoint.new(ctx, 0, nil)
+      callee_ep = ExecutionPoint.new(ctx, 0, @outer_ep)
 
       locals = [Type.nil] * @iseq.locals.size
       nenv = Env.new(StaticEnv.new(recv, msig.blk_ty, false, true), locals, [], Utils::HashWrapper.new({}))
@@ -95,16 +95,15 @@ module TypeProf
       idx = 0
       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, ty = scratch.localize_type(ty, nenv, callee_ep, alloc_site2)
         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, ty = scratch.localize_type(ty, nenv, callee_ep, alloc_site2)
           nenv = nenv.local_update(lead_num + i, ty)
         end
       end
@@ -112,27 +111,27 @@ module TypeProf
         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, rest_ty = scratch.localize_type(ty, nenv, callee_ep, alloc_site2)
         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, ty = scratch.localize_type(ty, nenv, callee_ep, alloc_site2)
           nenv = nenv.local_update(post_start + i, ty)
         end
       end
-      if msig.kw_tys
+      if msig.kw_tys && keyword # TODO: support the case where RBS writes kw_tys and RB method accepts **kwrest
         msig.kw_tys.each do |_, key, ty|
-          i = keyword.index(key)
+          i = keyword.index {|callee_key,| callee_key == 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, ty = scratch.localize_type(ty, nenv, callee_ep, alloc_site2)
           nenv = nenv.local_update(kw_start + i, ty)
         end
       end
@@ -140,14 +139,15 @@ module TypeProf
         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, ty = scratch.localize_type(ty, nenv, callee_ep, alloc_site2)
         nenv = nenv.local_update(kw_rest, ty)
       end
       nenv = nenv.local_update(block_start, msig.blk_ty) if block_start
 
       opt.each do |start_pc|
-        scratch.merge_env(ExecutionPoint.new(ctx, start_pc, nil), nenv)
+        scratch.merge_env(callee_ep.jump(start_pc), nenv)
       end
+      scratch.add_executed_iseq(@iseq)
 
       ctx
     end
@@ -166,8 +166,8 @@ module TypeProf
       case @kind
       when :reader
         if aargs.lead_tys.size == 0
-          scratch.get_instance_variable(recv, @ivar, caller_ep, caller_env) do |ty, nenv|
-            ctn[ty, caller_ep, nenv]
+          scratch.add_ivar_read!(recv, @ivar, caller_ep) do |ty, _ep|
+            ctn[ty, caller_ep, caller_env]
           end
         else
           ctn[Type.any, caller_ep, caller_env]
@@ -291,7 +291,6 @@ module TypeProf
     end
 
     def do_send(recv, mid, aargs, caller_ep, caller_env, scratch, &ctn)
-      scratch.merge_return_env(caller_ep) {|env| env ? env.merge(caller_env) : caller_env } # for Kernel#lambda
       @impl[recv, mid, aargs, caller_ep, caller_env, scratch, &ctn]
     end
   end

data/lib/typeprof/type.rb

@@ -315,9 +315,14 @@ module TypeProf
       def globalize(env, visited, depth)
         return Type.any if depth <= 0
         tys = Utils::Set[]
-        raise if @elems
+        if @elems
+          # XXX: If @elems is non nil, the Union type should global, so calling globalize against such a type should not occur.
+          # However, currently, ActualArguments may contain global types for flag_args_kw_splat case.
+          # This should be fixed in future in ActualArguments side. See Scratch#setup_actual_arguments.
+          #raise
+        end
 
-        elems = {}
+        elems = @elems ? @elems.dup : {}
         @types.each do |ty|
           ty = ty.globalize(env, visited, depth - 1)
           case ty
@@ -492,6 +497,8 @@ module TypeProf
       def initialize(klass)
         raise unless klass
         raise if klass == Type.any
+        raise if klass.is_a?(Type::Instance)
+        raise if klass.is_a?(Type::Union)
         @klass = klass
       end
 
@@ -682,6 +689,8 @@ module TypeProf
         Type::Literal.new(obj, Type::Instance.new(Type::Builtin[:int]))
       when ::Rational
         Type::Literal.new(obj, Type::Instance.new(Type::Builtin[:rational]))
+      when ::Complex
+        Type::Literal.new(obj, Type::Instance.new(Type::Builtin[:complex]))
       when ::Float
         Type::Literal.new(obj, Type::Instance.new(Type::Builtin[:float]))
       when ::Class
@@ -718,6 +727,8 @@ module TypeProf
         Type.nil
       when ::Range
         Type::Literal.new(obj, Type::Instance.new(Type::Builtin[:range]))
+      when ::Encoding
+        Type::Literal.new(obj, Type::Instance.new(Type::Builtin[:encoding]))
       else
         raise "unknown object: #{ obj.inspect }"
       end
@@ -820,6 +831,7 @@ module TypeProf
     def initialize(lead_tys, opt_tys, rest_ty, post_tys, kw_tys, kw_rest_ty, blk_ty)
       @lead_tys = lead_tys
       @opt_tys = opt_tys
+      raise unless opt_tys.is_a?(Array)
       @rest_ty = rest_ty
       @post_tys = post_tys
       raise unless post_tys
@@ -842,6 +854,44 @@ module TypeProf
       MethodSignature.new(lead_tys, opt_tys, rest_ty, post_tys, kw_tys, kw_rest_ty, blk_ty)
     end
 
+    def merge_as_block_arguments(other)
+      lead_tys1, opt_tys1, rest_ty1, post_tys1 = @lead_tys, @opt_tys, @rest_ty, @post_tys
+      lead_tys2, opt_tys2, rest_ty2, post_tys2 = other.lead_tys, other.opt_tys, other.rest_ty, other.post_tys
+
+      case
+      when lead_tys1.size > lead_tys2.size
+        n = lead_tys2.size
+        lead_tys1, opt_tys1 = lead_tys1[0, n], lead_tys1[n..] + opt_tys1
+      when lead_tys1.size < lead_tys2.size
+        n = lead_tys1.size
+        lead_tys2, opt_tys2 = lead_tys2[0, n], lead_tys2[n..] + opt_tys2
+      end
+      case
+      when post_tys1.size > post_tys2.size
+        i = post_tys1.size - post_tys2.size
+        if rest_ty1
+          rest_ty1 = post_tys[0, i].inject(rest_ty1) {|ty1, ty2| ty1.union(ty2) }
+          post_tys1 = post_tys1[i..]
+        else
+          opt_tys1, post_tys1 = opt_tys1 + post_tys1[0, i], post_tys1[i..]
+        end
+      when post_tys1.size < post_tys2.size
+        i = post_tys2.size - post_tys1.size
+        if rest_ty2
+          rest_ty2 = post_tys[0, i].inject(rest_ty2) {|ty1, ty2| ty1.union(ty2) }
+          post_tys2 = post_tys2[i..]
+        else
+          opt_tys2, post_tys2 = opt_tys2 + post_tys2[0, i], post_tys2[i..]
+        end
+      end
+
+      # XXX: tweak keywords too
+
+      msig1 = MethodSignature.new(lead_tys1, opt_tys1, rest_ty1, post_tys1, @kw_tys, @kw_rest_ty, @blk_ty)
+      msig2 = MethodSignature.new(lead_tys2, opt_tys2, rest_ty2, post_tys2, other.kw_tys, other.kw_rest_ty, other.blk_ty)
+      msig1.merge(msig2)
+    end
+
     def merge(other)
       raise if @lead_tys.size != other.lead_tys.size
       raise if @post_tys.size != other.post_tys.size

data/lib/typeprof/version.rb

@@ -1,3 +1,3 @@
 module TypeProf
-  VERSION = "0.8.0"
+  VERSION = "0.9.0"
 end

data/smoke/alias.rb

@@ -21,11 +21,11 @@ __END__
 # Classes
 class Object
   private
-  def foo : (Integer) -> Integer
-  def bar : (String) -> String
+  def foo: (Integer) -> Integer
+  def bar: (String) -> String
 end
 
 class Test
-  def baz : (Integer) -> Integer
-  def qux : (String) -> String
+  def baz: (Integer) -> Integer
+  def qux: (String) -> String
 end

data/smoke/alias2.rb

@@ -12,8 +12,8 @@ Foo[:x, :y, :z]
 __END__
 # Classes
 class Foo
-  @a : :x
-  @b : :y
-  @c : :z
-  def initialize : (:x, :y, :z) -> [:x, :y, :z]
+  @a: :x
+  @b: :y
+  @c: :z
+  def initialize: (:x, :y, :z) -> [:x, :y, :z]
 end

data/smoke/any1.rb

@@ -12,5 +12,5 @@ smoke/any1.rb:2: [error] undefined method: Integer#undefined_method
 # Classes
 class Object
   private
-  def foo : -> untyped
+  def foo: -> untyped
 end

data/smoke/any2.rb

@@ -13,6 +13,6 @@ __END__
 # Classes
 class Object
   private
-  def foo : -> untyped
-  def bar : -> Integer
+  def foo: -> untyped
+  def bar: -> Integer
 end

data/smoke/arguments.rb

@@ -12,6 +12,6 @@ smoke/arguments.rb:6: [error] wrong number of arguments (given 2, expected 1)
 # Classes
 class Object
   private
-  def foo : (untyped) -> nil
-  def bar : (untyped) -> nil
+  def foo: (untyped) -> nil
+  def bar: (untyped) -> nil
 end

data/smoke/arguments2.rb

@@ -43,14 +43,14 @@ __END__
 # Classes
 class Object
   private
-  def f1 : -> nil
-  def f2 : (:x, :y, :z) -> nil
-  def f3 : (?String, ?String) -> nil
-  def f4 : (*:a | :b | :c) -> nil
-  def f5 : (:x, ?String, :z) -> nil
-  def f6 : (k: :kk) -> nil
-  def f7 : (?k: Integer) -> nil
-  def f8 : (?k: String) -> nil
-  def f9 : (**{k: :kk}) -> nil
-  def f10 : { (Integer) -> nil } -> nil
+  def f1: -> nil
+  def f2: (:x, :y, :z) -> nil
+  def f3: (?String, ?String) -> nil
+  def f4: (*:a | :b | :c) -> nil
+  def f5: (:x, ?String, :z) -> nil
+  def f6: (k: :kk) -> nil
+  def f7: (?k: Integer) -> nil
+  def f8: (?k: String) -> nil
+  def f9: (**{k: :kk}) -> nil
+  def f10: { (Integer) -> nil } -> nil
 end