typeprof 0.30.0 → 0.31.0

data/lib/typeprof/core/graph/box.rb

@@ -39,18 +39,12 @@ module TypeProf::Core
       @changes.reinstall(genv)
     end
 
-    def diagnostics(genv, &blk)
-      raise self.to_s if !@changes
-      @changes.diagnostics.each(&blk)
-      @changes.boxes.each_value do |box|
-        box.diagnostics(genv, &blk)
-      end
+    def run0(genv, changes)
+      raise NotImplementedError
     end
 
-    #@@new_id = 0
-
     def to_s
-      "#{ self.class.to_s.split("::").last[0] }#{ @id ||= $new_id += 1 }"
+      "#{ self.class.to_s.split("::").last }#{ @id ||= $new_id += 1 }"
     end
 
     alias inspect to_s
@@ -87,7 +81,20 @@ module TypeProf::Core
     attr_reader :node, :rbs_type, :ret
 
     def run0(genv, changes)
-      vtx = @rbs_type.covariant_vertex(genv, changes, {})
+      # Create substitution map for type parameters if we're in a SigInstanceVariableNode within a generic class
+      subst = {}
+      if @node.is_a?(AST::SigInstanceVariableNode) && @node.cpath
+        mod = genv.resolve_cpath(@node.cpath)
+        if mod.type_params && !mod.type_params.empty?
+          # Create a substitution map where each type parameter maps to a type variable vertex
+          subst = mod.type_params.to_h do |param|
+            type_var_vtx = Vertex.new(@node)
+            [param, type_var_vtx]
+          end
+        end
+      end
+
+      vtx = @rbs_type.covariant_vertex(genv, changes, subst)
       changes.add_edge(genv, vtx, @ret)
     end
   end
@@ -142,13 +149,11 @@ module TypeProf::Core
       end
 
       method_type.req_positionals.each_with_index do |ty, i|
-        f_arg = ty.contravariant_vertex(genv, changes, param_map)
-        return false unless a_args.positionals[i].check_match(genv, changes, f_arg)
+        return false unless ty.typecheck(genv, changes, a_args.positionals[i], param_map)
       end
       method_type.post_positionals.each_with_index do |ty, i|
-        f_arg = ty.contravariant_vertex(genv, changes, param_map)
         i -= method_type.post_positionals.size
-        return false unless a_args.positionals[i].check_match(genv, changes, f_arg)
+        return false unless ty.typecheck(genv, changes, a_args.positionals[i], param_map)
       end
 
       start_rest = method_type.req_positionals.size
@@ -157,61 +162,100 @@ module TypeProf::Core
       i = 0
       while i < method_type.opt_positionals.size && start_rest < end_rest
         break if a_args.splat_flags[start_rest]
-        f_arg = method_type.opt_positionals[i].contravariant_vertex(genv, changes, param_map)
-        return false unless a_args.positionals[start_rest].check_match(genv, changes, f_arg)
+        return false unless method_type.opt_positionals[i].typecheck(genv, changes, a_args.positionals[start_rest], param_map)
         i += 1
         start_rest += 1
       end
 
       if start_rest < end_rest
-        vtxs = a_args.get_rest_args(genv, start_rest, end_rest)
+        vtxs = a_args.get_rest_args(genv, changes, start_rest, end_rest)
         while i < method_type.opt_positionals.size
-          f_arg = method_type.opt_positionals[i].contravariant_vertex(genv, changes, param_map)
-          return false if vtxs.any? {|vtx| !vtx.check_match(genv, changes, f_arg) }
+          ty = method_type.opt_positionals[i]
+          return false if vtxs.any? {|vtx| !ty.typecheck(genv, changes, vtx, param_map) }
           i += 1
         end
         if method_type.rest_positionals
-          f_arg = method_type.rest_positionals.contravariant_vertex(genv, changes, param_map)
-          return false if vtxs.any? {|vtx| !vtx.check_match(genv, changes, f_arg) }
+          return false if vtxs.any? {|vtx| !method_type.rest_positionals.typecheck(genv, changes, vtx, param_map) }
         end
       end
 
       return true
     end
 
-    def resolve_overloads(changes, genv, node, param_map, a_args, ret)
-      match_any_overload = false
-      @method_types.each do |method_type|
-        param_map0 = param_map.dup
-        if method_type.type_params
-          method_type.type_params.zip(yield(method_type)) do |var, vtx|
-            param_map0[var] = vtx
-          end
+    def resolve_overload(changes, genv, method_type, node, param_map, a_args, ret, force)
+      param_map0 = param_map.dup
+      if method_type.type_params
+        method_type.type_params.zip(yield(method_type)) do |var, vtx|
+          param_map0[var] = vtx
         end
+      end
 
-        next unless match_arguments?(genv, changes, param_map0, a_args, method_type)
+      unless match_arguments?(genv, changes, param_map0, a_args, method_type)
+        if force
+          meth = node.mid_code_range ? :mid_code_range : :code_range
+          changes.add_diagnostic(meth, "wrong type of arguments") # XXX: more friendly and fine-grained error message
+        end
+        return false
+      end
 
-        rbs_blk = method_type.block
-        next if method_type.block_required && !a_args.block
-        next if !rbs_blk && a_args.block
-        if rbs_blk && a_args.block
-          # rbs_blk_func.optional_keywords, ...
-          a_args.block.each_type do |ty|
-            case ty
-            when Type::Proc
-              blk_f_ret = rbs_blk.return_type.contravariant_vertex(genv, changes, param_map0)
-              blk_a_args = rbs_blk.req_positionals.map do |blk_a_arg|
-                blk_a_arg.covariant_vertex(genv, changes, param_map0)
+      rbs_blk = method_type.block
+      if method_type.block_required && !a_args.block
+        if force
+          meth = node.mid_code_range ? :mid_code_range : :code_range
+          changes.add_diagnostic(meth, "block is expected") # XXX: more friendly error message
+        end
+        return false
+      end
+      if !rbs_blk && a_args.block
+        if force
+          meth = node.mid_code_range ? :mid_code_range : :code_range
+          changes.add_diagnostic(meth, "block is not expected") # XXX: more friendly error message
+        end
+        return false
+      end
+      if rbs_blk && a_args.block
+        # rbs_blk_func.optional_keywords, ...
+        blk_a_args = rbs_blk.req_positionals.map do |blk_a_arg|
+          blk_a_arg.covariant_vertex(genv, changes, param_map0)
+        end
+        a_args.block.each_type do |ty|
+          case ty
+          when Type::Proc
+            ty.block.accept_args(genv, changes, blk_a_args)
+
+            if ty.block.is_a?(Block)
+              ty.block.next_boxes.each do |next_box|
+                unless rbs_blk.return_type.typecheck(genv, changes, next_box.a_ret, param_map0)
+                  next_box.wrong_return_type(rbs_blk.return_type.show, changes)
+                end
               end
-
-              ty.block.accept_args(genv, changes, blk_a_args, blk_f_ret, true)
             end
           end
         end
-        ret_vtx = method_type.return_type.covariant_vertex(genv, changes, param_map0)
+      end
 
+      force = true
+      return true
+
+    ensure
+      if force
+        ret_vtx = method_type.return_type.covariant_vertex(genv, changes, param_map0)
         changes.add_edge(genv, ret_vtx, ret)
-        match_any_overload = true
+      end
+    end
+
+    def resolve_overloads(changes, genv, node, param_map, a_args, ret, &blk)
+      if @method_types.size == 1
+        method_type = @method_types.first
+        resolve_overload(changes, genv, method_type, node, param_map, a_args, ret, true, &blk)
+        return
+      end
+
+      match_any_overload = false
+      @method_types.each do |method_type|
+        if resolve_overload(changes, genv, method_type, node, param_map, a_args, ret, false, &blk)
+          match_any_overload = true
+        end
       end
       unless match_any_overload
         meth = node.mid_code_range ? :mid_code_range : :code_range
@@ -252,53 +296,66 @@ module TypeProf::Core
   end
 
   class EscapeBox < Box
-    def initialize(node, genv, a_ret, f_ret)
+    def initialize(node, genv, a_ret)
       super(node)
       @a_ret = a_ret.new_vertex(genv, node)
-      @f_ret = f_ret
-      @f_ret.add_edge(genv, self)
     end
 
-    attr_reader :a_ret, :f_ret
+    attr_reader :a_ret
 
     def ret = @a_ret
 
     def run0(genv, changes)
-      unless @a_ret.check_match(genv, changes, @f_ret)
-        msg = "expected: #{ @f_ret.show }; actual: #{ @a_ret.show }"
-        case @node
-        when AST::ReturnNode
-          changes.add_diagnostic(:code_range, msg)
-        when AST::DefNode
-          changes.add_diagnostic(:last_stmt_code_range, msg)
-        when AST::NextNode
-          changes.add_diagnostic(:code_range, msg)
-        when AST::CallNode
-          changes.add_diagnostic(:block_last_stmt_code_range, msg)
-        when AST::AttrReaderMetaNode, AST::AttrAccessorMetaNode
-          changes.add_diagnostic(:code_range, msg)
-        else
-          pp @node.class
-        end
+      return
+    end
+
+    def wrong_return_type(f_ret_show, changes)
+      actual_ty = @a_ret.show
+      return if actual_ty == "untyped" # XXX: too ad-hoc?
+      msg = "expected: #{ f_ret_show }; actual: #{ actual_ty }"
+      case @node
+      when AST::ReturnNode
+        changes.add_diagnostic(:code_range, msg, @node)
+      when AST::DefNode
+        changes.add_diagnostic(:last_stmt_code_range, msg, @node)
+      when AST::NextNode
+        changes.add_diagnostic(:code_range, msg, @node)
+      when AST::CallNode
+        changes.add_diagnostic(:block_last_stmt_code_range, msg, @node)
+      when AST::AttrReaderMetaNode, AST::AttrAccessorMetaNode
+        changes.add_diagnostic(:code_range, msg, @node)
+      else
+        pp @node.class
       end
     end
   end
 
   class SplatBox < Box
-    def initialize(node, genv, ary)
+    def initialize(node, genv, ary, idx)
       super(node)
       @ary = ary
+      @idx = idx
       @ary.add_edge(genv, self)
       @ret = Vertex.new(node)
     end
 
-    attr_reader :ary, :ret
+    attr_reader :ary, :idx, :ret
 
     def run0(genv, changes)
       @ary.each_type do |ty|
-        ty = ty.base_type(genv)
-        if ty.mod == genv.mod_ary
-          changes.add_edge(genv, ty.args[0], @ret)
+        case ty
+        when Type::Instance
+          if ty.mod == genv.mod_ary
+            changes.add_edge(genv, ty.args[0], @ret)
+          else
+            "???"
+          end
+        when Type::Array
+          if @idx && @idx < ty.elems.size
+            changes.add_edge(genv, ty.elems[@idx], @ret)
+          else
+            changes.add_edge(genv, ty.get_elem(genv, @idx), @ret)
+          end
         else
           "???"
         end
@@ -323,8 +380,8 @@ module TypeProf::Core
       @hsh.each_type do |ty|
         ty = ty.base_type(genv)
         if ty.mod == genv.mod_hash
-          changes.add_edge(genv, ty.args[0], @unified_key)
-          changes.add_edge(genv, ty.args[1], @unified_val)
+          changes.add_edge(genv, ty.args[0].new_vertex(genv, :__hash_splat), @unified_key)
+          changes.add_edge(genv, ty.args[1].new_vertex(genv, :__hash_splat), @unified_val)
         else
           "???"
         end
@@ -355,11 +412,8 @@ module TypeProf::Core
       end
       me = genv.resolve_method(@cpath, @singleton, @mid)
       me.add_def(self)
-      if me.decls.empty?
-        me.add_run_all_method_call_boxes(genv)
-      else
-        genv.add_run(self)
-      end
+      me.add_run_all_method_call_boxes(genv) if me.decls.empty?
+      genv.add_run(self)
     end
 
     attr_accessor :node
@@ -369,11 +423,8 @@ module TypeProf::Core
     def destroy(genv)
       me = genv.resolve_method(@cpath, @singleton, @mid)
       me.remove_def(self)
-      if me.decls.empty?
-        me.add_run_all_method_call_boxes(genv)
-      else
-        genv.add_run(self)
-      end
+      me.add_run_all_method_call_boxes(genv) if me.decls.empty?
+      genv.add_run(self)
       super(genv)
     end
 
@@ -430,8 +481,11 @@ module TypeProf::Core
       if pass_arguments(changes, genv, a_args)
         # TODO: block
         f_ret = method_type.return_type.contravariant_vertex(genv, changes, param_map0)
+        changes.add_edge(genv, f_ret, @ret)
         @ret_boxes.each do |ret_box|
-          changes.add_edge(genv, f_ret, ret_box.f_ret)
+          unless method_type.return_type.typecheck(genv, changes, ret_box.a_ret, param_map0)
+            ret_box.wrong_return_type(method_type.return_type.show, changes)
+          end
         end
       end
     end
@@ -451,7 +505,7 @@ module TypeProf::Core
 
         start_rest = [a_args.splat_flags.index(true), @f_args.req_positionals.size + @f_args.opt_positionals.size].min
         end_rest = [a_args.splat_flags.rindex(true) + 1, a_args.positionals.size - @f_args.post_positionals.size].max
-        rest_vtxs = a_args.get_rest_args(genv, start_rest, end_rest)
+        rest_vtxs = a_args.get_rest_args(genv, changes, start_rest, end_rest)
 
         @f_args.req_positionals.each_with_index do |f_vtx, i|
           if i < start_rest
@@ -485,7 +539,11 @@ module TypeProf::Core
 
         if @f_args.rest_positionals
           rest_vtxs.each do |vtx|
-            changes.add_edge(genv, vtx, @f_args.rest_positionals)
+            @f_args.rest_positionals.each_type do |ty|
+              if ty.is_a?(Type::Instance) && ty.mod == genv.mod_ary && ty.args[0]
+                changes.add_edge(genv, vtx, ty.args[0])
+              end
+            end
           end
         end
       else
@@ -519,9 +577,12 @@ module TypeProf::Core
 
         if start_rest < end_rest
           if @f_args.rest_positionals
-            f_arg = @f_args.rest_positionals
             (start_rest..end_rest-1).each do |i|
-              changes.add_edge(genv, a_args.positionals[i], f_arg)
+              @f_args.rest_positionals.each_type do |ty|
+                if ty.is_a?(Type::Instance) && ty.mod == genv.mod_ary && ty.args[0]
+                  changes.add_edge(genv, a_args.positionals[i], ty.args[0])
+                end
+              end
             end
           end
         end
@@ -569,7 +630,7 @@ module TypeProf::Core
         args << ("?" + Type.strip_parens(f_vtx.show))
       end
       if @f_args.rest_positionals
-        args << ("*" + Type.strip_parens(@f_args.rest_positionals.show))
+        args << ("*" + Type.strip_array(Type.strip_parens(@f_args.rest_positionals.show)))
       end
       @f_args.post_positionals.each do |var|
         args << Type.strip_parens(var.show)
@@ -583,7 +644,7 @@ module TypeProf::Core
         end
       end
       if @f_args.rest_keywords
-        args << "**#{ Type.strip_parens(@f_args.rest_keywords.show) }"
+        args << "**#{ Type.extract_hash_value_type(Type.strip_parens(@f_args.rest_keywords.show)) }"
       end
 
       if output_parameter_names && @node.is_a?(AST::DefNode)
@@ -603,7 +664,7 @@ module TypeProf::Core
       args = args.join(", ")
       s = args.empty? ? [] : ["(#{ args })"]
       s << "#{ block_show.sort.join(" | ") }" unless block_show.empty?
-      s << "-> #{ @ret.show }"
+      s << "-> #{ @mid == :initialize ? "void" : @ret.show }"
       s.join(" ")
     end
   end
@@ -619,11 +680,8 @@ module TypeProf::Core
 
       me = genv.resolve_method(@cpath, @singleton, @new_mid)
       me.add_alias(self, @old_mid)
-      if me.decls.empty?
-        me.add_run_all_method_call_boxes(genv)
-      else
-        genv.add_run(self)
-      end
+      me.add_run_all_method_call_boxes(genv) if me.decls.empty?
+      genv.add_run(self)
     end
 
     attr_accessor :node
@@ -633,11 +691,8 @@ module TypeProf::Core
     def destroy(genv)
       me = genv.resolve_method(@cpath, @singleton, @new_mid)
       me.remove_alias(self)
-      if me.decls.empty?
-        me.add_run_all_method_call_boxes(genv)
-      else
-        genv.add_run(self)
-      end
+      me.add_run_all_method_call_boxes(genv) if me.decls.empty?
+      genv.add_run(self)
       super(genv)
     end
 
@@ -654,7 +709,6 @@ module TypeProf::Core
       @recv.add_edge(genv, self)
       @mid = mid
       @a_args = a_args.new_vertexes(genv, node)
-      @a_args.positionals.each {|arg| arg.add_edge(genv, self) }
       @a_args.keywords.add_edge(genv, self) if @a_args.keywords
       @a_args.block.add_edge(genv, self) if @a_args.block
       @ret = Vertex.new(node)
@@ -742,6 +796,16 @@ module TypeProf::Core
         alias_limit = 0
         while ty
           unless skip
+            # First check prepended modules
+            if !ty.is_a?(Type::Singleton)
+              if resolve_prepended_modules(genv, changes, base_ty_env, ty, mid) do |me, ty, mid|
+                  yield me, ty, mid, orig_ty
+                end
+                break
+              end
+            end
+
+            # Then check the class/module itself
             me = ty.mod.get_method(ty.is_a?(Type::Singleton), mid)
             changes.add_depended_method_entity(me) if changes
             if !me.aliases.empty?
@@ -760,6 +824,7 @@ module TypeProf::Core
           if ty.is_a?(Type::Singleton)
             # TODO: extended modules
           else
+            # Finally check included modules
             break if resolve_included_modules(genv, changes, base_ty_env, ty, mid) do |me, ty, mid|
               yield me, ty, mid, orig_ty
             end
@@ -772,6 +837,38 @@ module TypeProf::Core
       end
     end
 
+    def resolve_prepended_modules(genv, changes, base_ty_env, ty, mid, &blk)
+      found = false
+
+      alias_limit = 0
+      # Process prepended modules in reverse order (last prepended = first in ancestor chain)
+      ty.mod.prepended_modules.reverse_each do |prep_decl, prep_mod|
+        if prep_decl.is_a?(AST::SigPrependNode) && prep_mod.type_params
+          prep_ty = genv.get_instance_type(prep_mod, prep_decl.args, changes, base_ty_env, ty)
+        else
+          type_params = prep_mod.type_params.map {|ty_param| Source.new() } # TODO: better support
+          prep_ty = Type::Instance.new(genv, prep_mod, type_params)
+        end
+
+        me = prep_ty.mod.get_method(false, mid)
+        changes.add_depended_method_entity(me) if changes
+        if !me.aliases.empty?
+          mid = me.aliases.values.first
+          alias_limit += 1
+          redo if alias_limit < 5
+        end
+        if me.exist?
+          found = true
+          yield me, prep_ty, mid
+        else
+          found = resolve_prepended_modules(genv, changes, base_ty_env, prep_ty, mid, &blk)
+        end
+        break if found
+      end
+
+      found
+    end
+
     def resolve_included_modules(genv, changes, base_ty_env, ty, mid, &blk)
       found = false
 
@@ -988,4 +1085,24 @@ module TypeProf::Core
       end
     end
   end
+
+  class InstanceTypeBox < Box
+    def initialize(node, genv, singleton_ty_vtx)
+      super(node)
+      @singleton_ty_vtx = singleton_ty_vtx
+      @ret = Vertex.new(node)
+      genv.add_run(self)
+    end
+
+    attr_reader :ret
+
+    def run0(genv, changes)
+      instance_tys = []
+      @singleton_ty_vtx.each_type do |ty|
+        instance_tys << ty.get_instance_type(genv)
+      end
+      source_vtx = Source.new(*instance_tys)
+      changes.add_edge(genv, source_vtx, @ret)
+    end
+  end
 end