typeprof 0.3.0 → 0.4.0

data/lib/typeprof/type.rb

@@ -148,7 +148,7 @@ module TypeProf
         # invariant check
         local = nil
         tys.each do |ty|
-          raise unless ty.is_a?(Type)
+          raise ty.inspect unless ty.is_a?(Type)
           local = true if ty.is_a?(LocalArray) || ty.is_a?(LocalHash)
         end
         raise if local && elems
@@ -226,12 +226,15 @@ module TypeProf
             bool = true
           end
           types.delete(Type.any) unless Config.options[:pedantic_output]
+          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?
           types << "bool" if bool
           types = types.sort
           if optional
-            if types.size == 1
-              types.first + "?"
+            case types.size
+            when 0 then "nil"
+            when 1 then types.first + "?"
             else
               "(#{ types.join (" | ") })?"
             end
@@ -516,56 +519,51 @@ module TypeProf
       end
     end
 
-    class ISeqProc < Type
-      def initialize(iseq, ep, type)
-        @iseq = iseq
-        @ep = ep
-        @type = type
+    class Proc < Type
+      def initialize(block_body, type)
+        @block_body, @type = block_body, type
       end
 
-      attr_reader :iseq, :ep, :type
-
-      def inspect
-        "#<ISeqProc>"
-      end
+      attr_reader :block_body, :type
 
-      def screen_name(scratch)
-        "Proc[#{ scratch.proc_screen_name(self) }]" # TODO: use RBS syntax
+      def consistent?(other, subst)
+        case other
+        when Type::Any then true
+        when Type::Var then other.add_subst!(self, subst)
+        when Type::Union
+          other.types.each do |ty2|
+            return true if consistent?(ty2, subst)
+          end
+        when Type::Proc
+          @block_body.consistent?(other.block_body)
+        else
+          self == other
+        end
       end
 
       def get_method(mid, scratch)
         @type.get_method(mid, scratch)
       end
 
-      def substitute(_subst, _depth)
-        self # XXX
-      end
-    end
-
-    class TypedProc < Type
-      def initialize(fargs, ret_ty, type)
-        @fargs = fargs
-        @ret_ty = ret_ty
-        @type = type
+      def substitute(subst, depth)
+        Proc.new(@block_body.substitute(subst, depth), @type)
       end
 
-      attr_reader :fargs, :ret_ty
-
       def screen_name(scratch)
-        "TypedProc[...]" # TODO: use RBS syntax
+        scratch.show_proc_signature([self])
       end
     end
 
     class Symbol < Type
-      def initialize(sym, type)
+      def initialize(sym, base_type)
         @sym = sym
-        @type = type
+        @base_type = base_type
       end
 
-      attr_reader :sym, :type
+      attr_reader :sym, :base_type
 
       def inspect
-        "Type::Symbol[#{ @sym ? @sym.inspect : "(dynamic symbol)" }, #{ @type.inspect }]"
+        "Type::Symbol[#{ @sym ? @sym.inspect : "(dynamic symbol)" }, #{ @base_type.inspect }]"
       end
 
       def consistent?(other, subst)
@@ -575,7 +573,7 @@ module TypeProf
         when Symbol
           @sym == other.sym
         else
-          @type.consistent?(other, subst)
+          @base_type.consistent?(other, subst)
         end
       end
 
@@ -583,12 +581,12 @@ module TypeProf
         if @sym
           @sym.inspect
         else
-          @type.screen_name(scratch)
+          @base_type.screen_name(scratch)
         end
       end
 
       def get_method(mid, scratch)
-        @type.get_method(mid, scratch)
+        @base_type.get_method(mid, scratch)
       end
 
       def substitute(_subst, _depth)
@@ -747,66 +745,74 @@ module TypeProf
     end
   end
 
-  # Arguments for callee side
-  class FormalArguments
+  class Signature
     include Utils::StructuralEquality
 
-    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
-      @rest_ty = rest_ty
-      @post_tys = post_tys
-      @kw_tys = kw_tys
-      kw_tys.each {|a| raise if a.size != 3 } if kw_tys
-      @kw_rest_ty = kw_rest_ty
-      @blk_ty = blk_ty
-    end
-
-    attr_reader :lead_tys, :opt_tys, :rest_ty, :post_tys, :kw_tys, :kw_rest_ty, :blk_ty
-
-    def consistent?(fargs, subst)
-      warn "used?"
-      return false if @lead_tys.size != fargs.lead_tys.size
-      return false unless @lead_tys.zip(fargs.lead_tys).all? {|ty1, ty2| ty1.consistent?(ty2, subst) }
-      return false if (@opt_tys || []) != (fargs.opt_tys || []) # ??
-      if @rest_ty
-        return false unless @rest_ty.consistent?(fargs.rest_ty, subst)
-      end
-      if @post_tys
-        return false if @post_tys.size != fargs.post_tys.size
-        return false unless @post_tys.zip(fargs.post_tys).all? {|ty1, ty2| ty1.consistent?(ty2, subst) }
-      end
-      return false if @kw_tys.size != fargs.kw_tys.size
-      return false unless @kw_tys.zip(fargs.kw_tys).all? {|(_, ty1), (_, ty2)| ty1.consistent?(ty2, subst) }
-      if @kw_rest_ty
-        return false unless @kw_rest_ty.consistent?(fargs.kw_rest_ty, subst)
-      end
-      # intentionally skip blk_ty
-      true
-    end
-
     def screen_name(scratch)
-      fargs = @lead_tys.map {|ty| ty.screen_name(scratch) }
+      str = @lead_tys.map {|ty| ty.screen_name(scratch) }
       if @opt_tys
-        fargs += @opt_tys.map {|ty| "?" + ty.screen_name(scratch) }
+        str += @opt_tys.map {|ty| "?" + ty.screen_name(scratch) }
       end
       if @rest_ty
-        fargs << ("*" + @rest_ty.screen_name(scratch))
+        str << ("*" + @rest_ty.screen_name(scratch))
       end
       if @post_tys
-        fargs += @post_tys.map {|ty| ty.screen_name(scratch) }
+        str += @post_tys.map {|ty| ty.screen_name(scratch) }
       end
       if @kw_tys
         @kw_tys.each do |req, sym, ty|
           opt = req ? "" : "?"
-          fargs << "#{ opt }#{ sym }: #{ ty.screen_name(scratch) }"
+          str << "#{ opt }#{ sym }: #{ ty.screen_name(scratch) }"
         end
       end
       if @kw_rest_ty
-        fargs << ("**" + @kw_rest_ty.screen_name(scratch))
+        str << ("**" + @kw_rest_ty.screen_name(scratch))
+      end
+      str = str.empty? ? "" : "(#{ str.join(", ") })"
+
+      optional = false
+      blks = []
+      @blk_ty.each_child_global do |ty|
+        if ty.is_a?(Type::Proc)
+          blks << ty
+        else
+          # XXX: how should we handle types other than Type.nil
+          optional = true
+        end
       end
-      # intentionally skip blk_ty
-      fargs
+      if blks != []
+        str << " " if str != ""
+        str << "?" if optional
+        str << scratch.show_block_signature(blks)
+      end
+
+      str
+    end
+  end
+
+  class MethodSignature < Signature
+    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
+      @rest_ty = rest_ty
+      @post_tys = post_tys
+      @kw_tys = kw_tys
+      kw_tys.each {|a| raise if a.size != 3 } if kw_tys
+      @kw_rest_ty = kw_rest_ty
+      @blk_ty = blk_ty
+    end
+
+    attr_reader :lead_tys, :opt_tys, :rest_ty, :post_tys, :kw_tys, :kw_rest_ty, :blk_ty
+
+    def substitute(subst, depth)
+      lead_tys = @lead_tys.map {|ty| ty.substitute(subst, depth - 1) }
+      opt_tys = @opt_tys.map {|ty| ty.substitute(subst, depth - 1) }
+      rest_ty = @rest_ty&.substitute(subst, depth - 1)
+      post_tys = @post_tys.map {|ty| ty.substitute(subst, depth - 1) }
+      kw_tys = @kw_tys.map {|req, key, ty| [req, key, ty.substitute(subst, depth - 1)] }
+      kw_rest_ty = @kw_rest_ty&.substitute(subst, depth - 1)
+      blk_ty = @blk_ty.substitute(subst, depth - 1)
+      MethodSignature.new(lead_tys, opt_tys, rest_ty, post_tys, kw_tys, kw_rest_ty, blk_ty)
     end
 
     def merge(other)
@@ -868,250 +874,60 @@ module TypeProf
         end
       end
       blk_ty = @blk_ty.union(other.blk_ty) if @blk_ty
-      FormalArguments.new(lead_tys, opt_tys, rest_ty, post_tys, kw_tys, kw_rest_ty, blk_ty)
+      MethodSignature.new(lead_tys, opt_tys, rest_ty, post_tys, kw_tys, kw_rest_ty, blk_ty)
     end
   end
 
-  # Arguments from caller side
-  class ActualArguments
-    def initialize(lead_tys, rest_ty, kw_tys, blk_ty)
+  class BlockSignature < Signature
+    def initialize(lead_tys, opt_tys, rest_ty, blk_ty)
       @lead_tys = lead_tys
+      @opt_tys = opt_tys
       @rest_ty = rest_ty
-      @kw_tys = kw_tys # kw_tys should be {:key1 => Type.bool, :key2 => Type.bool, ...} or {nil => Type.bool}
-      raise if !kw_tys.is_a?(::Hash)
       @blk_ty = blk_ty
-      raise unless blk_ty
-    end
-
-    attr_reader :lead_tys, :rest_ty, :kw_tys, :blk_ty
-
-    def merge(aargs)
-      len = [@lead_tys.size, aargs.lead_tys.size].min
-      lead_tys = @lead_tys[0, len].zip(aargs.lead_tys[0, len]).map do |ty1, ty2|
-        ty1.union(ty2)
-      end
-      rest_ty = @rest_ty || Type.bot
-      rest_ty = rest_ty.union(aargs.rest_ty) if aargs.rest_ty
-      (@lead_tys[len..] + aargs.lead_tys[len..]).each do |ty|
-        rest_ty = rest_ty.union(ty)
-      end
-      rest_ty = nil if rest_ty == Type.bot
-      kw_tys = @kw_tys.dup
-      aargs.kw_tys.each do |sym, ty|
-        if kw_tys[sym]
-          kw_tys[sym] = kw_tys[sym].union(ty)
-        else
-          kw_tys[sym] = ty
-        end
-      end
-      blk_ty = @blk_ty.union(aargs.blk_ty)
-      ActualArguments.new(lead_tys, rest_ty, kw_tys, blk_ty)
-    end
-
-    def globalize(caller_env, visited, depth)
-      lead_tys = @lead_tys.map {|ty| ty.globalize(caller_env, visited, depth) }
-      rest_ty = @rest_ty.globalize(caller_env, visited, depth) if @rest_ty
-      kw_tys = @kw_tys.to_h do |key, ty|
-        [key, ty.globalize(caller_env, visited, depth)]
-      end
-      ActualArguments.new(lead_tys, rest_ty, kw_tys, @blk_ty)
-    end
-
-    def limit_size(limit)
-      self
-    end
-
-    def each_formal_arguments(fargs_format)
-      lead_num = fargs_format[:lead_num] || 0
-      post_num = fargs_format[:post_num] || 0
-      rest_acceptable = !!fargs_format[:rest_start]
-      keyword = fargs_format[:keyword]
-      kw_rest_acceptable = !!fargs_format[:kwrest]
-      opt = fargs_format[:opt]
-      #p fargs_format
-
-      # TODO: expand tuples to normal arguments
-
-      # check number of arguments
-      if !@rest_ty && lead_num + post_num > @lead_tys.size
-        # too less
-        yield "wrong number of arguments (given #{ @lead_tys.size }, expected #{ lead_num + post_num })"
-        return
-      end
-      if !rest_acceptable
-        # too many
-        if opt
-          if lead_num + post_num + opt.size - 1 < @lead_tys.size
-            yield "wrong number of arguments (given #{ @lead_tys.size }, expected #{ lead_num + post_num }..#{ lead_num + post_num + opt.size - 1})"
-            return
-          end
-        else
-          if lead_num + post_num < @lead_tys.size
-            yield "wrong number of arguments (given #{ @lead_tys.size }, expected #{ lead_num + post_num })"
-            return
-          end
-        end
-      end
-
-      if @rest_ty
-        lower_bound = [lead_num + post_num - @lead_tys.size, 0].max
-        upper_bound = lead_num + post_num - @lead_tys.size + (opt ? opt.size - 1 : 0) + (rest_acceptable ? 1 : 0)
-        rest_elem = @rest_ty.is_a?(Type::Array) ? @rest_ty.elems.squash : Type.any
-      else
-        lower_bound = upper_bound = 0
-      end
-
-      a_kw_tys = @kw_tys.dup
-      if keyword
-        kw_tys = []
-        keyword.each do |kw|
-          case
-          when kw.is_a?(Symbol) # required keyword
-            key = kw
-            req = true
-          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)
-            req = false
-          else # optional keyword (default value is an expression)
-            key, = kw
-            req = false
-          end
-
-          if a_kw_tys.key?(key)
-            ty = a_kw_tys.delete(key)
+      # TODO: kw_tys
+    end
+
+    attr_reader :lead_tys, :opt_tys, :rest_ty, :blk_ty
+
+    def merge(bsig)
+      if @rest_ty && bsig.rest_ty
+        rest_ty = @rest_ty.union(bsig.rest_ty)
+        BlockSignature.new(@lead_tys, [], rest_ty, @blk_ty.union(bsig.blk_ty))
+      elsif @rest_ty || bsig.rest_ty
+        rest_ty = @rest_ty || bsig.rest_ty
+        rest_ty = @opt_tys.inject(rest_ty, &:union)
+        rest_ty = bsig.opt_tys.inject(rest_ty, &:union)
+
+        lead_tys = []
+        [@lead_tys.size, bsig.lead_tys.size].max.times do |i|
+          ty1 = @lead_tys[i]
+          ty2 = bsig.lead_tys[i]
+          if ty1 && ty2
+            lead_tys << ty1.union(ty2)
           else
-            ty = a_kw_tys[nil] || Type.bot
-          end
-          if ty == Type.bot && req
-            yield "no argument for required keywords"
-            return
-          end
-          ty = ty.union(default_ty) if default_ty
-          kw_tys << [req, key, ty]
-        end
-      end
-      if kw_rest_acceptable
-        if a_kw_tys.key?(nil)
-          kw_rest_ty = Type.gen_hash {|h| h[Type.any] = a_kw_tys[nil] }
-        else
-          kw_rest_ty = Type.gen_hash do |h|
-            a_kw_tys.each do |key, ty|
-              sym = Type::Symbol.new(key, Type::Instance.new(Type::Builtin[:sym]))
-              h[sym] = ty
-            end
+            rest_ty = rest_ty.union(ty1 || ty2)
           end
         end
-      end
-      #if @kw_tys
-      #  yield "passed a keyword to non-keyword method"
-      #end
-
-      (lower_bound .. upper_bound).each do |rest_len|
-        aargs = @lead_tys + [rest_elem] * rest_len
-        lead_tys = aargs.shift(lead_num)
-        lead_tys << rest_elem until lead_tys.size == lead_num
-        post_tys = aargs.pop(post_num)
-        post_tys.unshift(rest_elem) until post_tys.size == post_num
-        start_pc = 0
-        if opt
-          tmp_opt = opt[1..]
-          opt_tys = []
-          until aargs.empty? || tmp_opt.empty?
-            opt_tys << aargs.shift
-            start_pc = tmp_opt.shift
-          end
-        end
-        if rest_acceptable
-          acc = aargs.inject {|acc, ty| acc.union(ty) }
-          acc = acc ? acc.union(rest_elem) : rest_elem if rest_elem
-          acc ||= Type.bot
-          rest_ty = acc
-          aargs.clear
-        end
-        if !aargs.empty?
-          yield "wrong number of arguments (given #{ @lead_tys.size }, expected #{ lead_num + post_num })"
-          return
-        end
-        yield FormalArguments.new(lead_tys, opt_tys, rest_ty, post_tys, kw_tys, kw_rest_ty, @blk_ty), start_pc
-      end
-    end
-
-    def consistent_with_formal_arguments?(fargs, subst)
-      aargs = @lead_tys.dup
 
-      # aargs: lead_tys, rest_ty
-      # fargs: lead_tys, opt_tys, rest_ty, post_tys
-      if @rest_ty
-        lower_bound = [0, fargs.lead_tys.size + fargs.post_tys.size - aargs.size].max
-        upper_bound = [0, lower_bound + fargs.opt_tys.size].max
-        (lower_bound..upper_bound).each do |n|
-          tmp_aargs = ActualArguments.new(@lead_tys + [@rest_ty] * n, nil, @kw_tys, @blk_ty)
-          if tmp_aargs.consistent_with_formal_arguments?(fargs, subst)
-            return true
-          end
-        end
-        return false
-      end
-
-      if fargs.rest_ty
-        return false if aargs.size < fargs.lead_tys.size + fargs.post_tys.size
-        aargs.shift(fargs.lead_tys.size).zip(fargs.lead_tys) do |aarg, farg|
-          return false unless aarg.consistent?(farg, subst)
-        end
-        aargs.pop(fargs.post_tys.size).zip(fargs.post_tys) do |aarg, farg|
-          return false unless aarg.consistent?(farg, subst)
-        end
-        fargs.opt_tys.each do |farg|
-          aarg = aargs.shift
-          return false unless aarg.consistent?(farg, subst)
-        end
-        aargs.each do |aarg|
-          return false unless aarg.consistent?(fargs.rest_ty, subst)
-        end
+        BlockSignature.new(lead_tys, [], rest_ty, @blk_ty.union(bsig.blk_ty))
       else
-        return false if aargs.size < fargs.lead_tys.size + fargs.post_tys.size
-        return false if aargs.size > fargs.lead_tys.size + fargs.post_tys.size + fargs.opt_tys.size
-        aargs.shift(fargs.lead_tys.size).zip(fargs.lead_tys) do |aarg, farg|
-          return false unless aarg.consistent?(farg, subst)
-        end
-        aargs.pop(fargs.post_tys.size).zip(fargs.post_tys) do |aarg, farg|
-          return false unless aarg.consistent?(farg, subst)
+        lead_tys = []
+        n = [@lead_tys.size, bsig.lead_tys.size].min
+        n.times do |i|
+          lead_tys << @lead_tys[i].union(bsig.lead_tys[i])
         end
-        aargs.zip(fargs.opt_tys) do |aarg, farg|
-          return false unless aarg.consistent?(farg, subst)
-        end
-      end
-      # XXX: fargs.keyword_tys
-
-      case fargs.blk_ty
-      when Type::TypedProc
-        return false if @blk_ty == Type.nil
-      when Type.nil
-        return false if @blk_ty != Type.nil
-      when Type::Any
-      else
-        raise "unknown typo of formal block signature"
-      end
-      true
-    end
-
-    def screen_name(scratch)
-      aargs = @lead_tys.map {|ty| ty.screen_name(scratch) }
-      if @rest_ty
-        aargs << ("*" + @rest_ty.screen_name(scratch))
-      end
-      if @kw_tys.key?(nil)
-        aargs << "(unknown key): #{ @kw_tys[nil].screen_name(scratch) }"
-      else
-        @kw_tys.sort.each do |key, ty|
-          aargs << "#{ key }: #{ ty.screen_name(scratch) }"
+        opt_tys1 = @lead_tys[n..] + @opt_tys
+        opt_tys2 = bsig.lead_tys[n..] + bsig.opt_tys
+        opt_tys = []
+        [opt_tys1.size, opt_tys2.size].max.times do |i|
+          if opt_tys1[i] && opt_tys2[i]
+            opt_tys << opt_tys1[i].union(opt_tys2[i])
+          else
+            opt_tys << (opt_tys1[i] || opt_tys2[i])
+          end
         end
+        BlockSignature.new(lead_tys, opt_tys, nil, @blk_ty.union(bsig.blk_ty))
       end
-      s = "(#{ aargs.join(", ") })"
-      s << " { #{ scratch.proc_screen_name(@blk_ty) } }" if @blk_ty != Type.nil
-      s
     end
   end
 end