typeprof 0.31.1 → 0.33.0

data/lib/typeprof/core/ast/method.rb

@@ -1,29 +1,25 @@
 module TypeProf::Core
   class AST
     def self.get_rbs_comment_before(raw_node, lenv)
-      comments = Fiber[:comments]
-      i = comments.bsearch_index {|comment| comment.location.start_line >= raw_node.location.start_line } || comments.size
-      lineno = raw_node.location.start_line
+      comments = lenv.file_context.comments
+      return nil unless comments
+      node_line = raw_node.location.start_line
+      last_comment_index = comments.bsearch_index {|c| c.location.start_line >= node_line } || comments.size
       rbs_comments = []
-      while i > 0
-        i -= 1
-        lineno -= 1
+      expected_line = node_line - 1
+      (last_comment_index - 1).downto(0) do |i|
         comment = comments[i]
+        break unless comment.location.start_line == expected_line && comment.location.slice.start_with?("#:")
         comment_loc = comment.location
         comment_text = comment_loc.slice
-        if comment_loc.start_line == lineno && comment_text.start_with?("#:")
-          rbs_comments[comment_loc.start_line] = " " * (comment_loc.start_column + 2) + comment_text[2..]
-        else
-          break
-        end
+        rbs_comments[comment_loc.start_line - 1] = " " * (comment_loc.start_column + 2) + comment_text[2..]
+        expected_line -= 1
       end
       return nil if rbs_comments.empty?
       rbs_comments = rbs_comments.map {|line| line || "" }.join("\n")
       method_type = RBS::Parser.parse_method_type(rbs_comments)
       if method_type
         AST.create_rbs_func_type(method_type, method_type.type_params, method_type.block, lenv)
-      else
-        nil
       end
     rescue RBS::ParsingError
       # TODO: report the error
@@ -34,23 +30,32 @@ module TypeProf::Core
       unless raw_args
         return {
           req_positionals: [],
+          req_multi_targets: {},
           opt_positionals: [],
           opt_positional_defaults: [],
           rest_positionals: nil,
           post_positionals: [],
+          post_multi_targets: {},
           req_keywords: [],
           opt_keywords: [],
           opt_keyword_defaults: [],
           rest_keywords: nil,
+          no_keywords: false,
           block: nil,
         }
       end
 
       args_code_ranges = []
       req_positionals = []
-      raw_args.requireds.each do |n|
-        args_code_ranges << TypeProf::CodeRange.from_node(n.location)
-        req_positionals << (n.is_a?(Prism::MultiTargetNode) ? nil : n.name)
+      req_multi_targets = {}
+      raw_args.requireds.each_with_index do |n, i|
+        args_code_ranges << lenv.code_range_from_node(n.location)
+        if n.is_a?(Prism::MultiTargetNode)
+          req_positionals << nil
+          req_multi_targets[i] = n
+        else
+          req_positionals << n.name
+        end
       end
 
       # pre_init = args[1]
@@ -62,13 +67,22 @@ module TypeProf::Core
         opt_positional_defaults << AST.create_node(n.value, lenv)
       end
 
-      post_positionals = raw_args.posts.map {|n| (n.is_a?(Prism::MultiTargetNode) ? nil : n.name) }
+      post_multi_targets = {}
+      post_positionals = raw_args.posts.each_with_index.map do |n, i|
+        if n.is_a?(Prism::MultiTargetNode)
+          post_multi_targets[i] = n
+          nil
+        else
+          n.name
+        end
+      end
 
       rest_positionals = raw_args.rest ? (raw_args.rest.name || :"*anonymous_rest") : nil
 
       req_keywords = []
       opt_keywords = []
       opt_keyword_defaults = []
+      no_keywords = false
 
       raw_args.keywords.each do |kw|
         case kw.type
@@ -88,7 +102,7 @@ module TypeProf::Core
         rest_positionals = :"..."
         rest_keywords = :"..."
       when Prism::NoKeywordsParameterNode
-        # what to do?
+        no_keywords = true
       when nil
         # nothing to do
       else
@@ -99,14 +113,17 @@ module TypeProf::Core
 
       {
         req_positionals:,
+        req_multi_targets:,
         opt_positionals:,
         opt_positional_defaults:,
         rest_positionals:,
         post_positionals:,
+        post_multi_targets:,
         req_keywords:,
         opt_keywords:,
         opt_keyword_defaults:,
         rest_keywords:,
+        no_keywords:,
         block:,
         args_code_ranges:
       }
@@ -118,7 +135,7 @@ module TypeProf::Core
         # TODO: warn "def self.foo" in a metaclass
         singleton = !!raw_node.receiver || lenv.cref.scope_level == :metaclass
         mid = raw_node.name
-        mid_code_range = TypeProf::CodeRange.from_node(raw_node.name_loc)
+        mid_code_range_loc = raw_node.name_loc
         @tbl = raw_node.locals
         raw_args = raw_node.parameters
         raw_body = raw_node.body
@@ -127,10 +144,10 @@ module TypeProf::Core
 
         @singleton = singleton
         @mid = mid
-        @mid_code_range = mid_code_range
+        @mid_code_range_loc = mid_code_range_loc
 
         ncref = CRef.new(lenv.cref.cpath, @singleton ? :class : :instance, @mid, lenv.cref)
-        nlenv = LocalEnv.new(@lenv.path, ncref, {}, [])
+        nlenv = LocalEnv.new(@lenv.file_context, ncref, {}, [])
         if raw_body
           @body = AST.create_node(raw_body, nlenv)
         else
@@ -141,14 +158,17 @@ module TypeProf::Core
 
         h = AST.parse_params(@tbl, raw_args, nlenv)
         @req_positionals = h[:req_positionals]
+        @req_multi_targets = h[:req_multi_targets]
         @opt_positionals = h[:opt_positionals]
         @opt_positional_defaults = h[:opt_positional_defaults]
         @rest_positionals = h[:rest_positionals]
         @post_positionals = h[:post_positionals]
+        @post_multi_targets = h[:post_multi_targets]
         @req_keywords = h[:req_keywords]
         @opt_keywords = h[:opt_keywords]
         @opt_keyword_defaults = h[:opt_keyword_defaults]
         @rest_keywords = h[:rest_keywords]
+        @no_keywords = h[:no_keywords]
         @block = h[:block]
         @args_code_ranges = h[:args_code_ranges] || []
 
@@ -157,7 +177,11 @@ module TypeProf::Core
         @reusable = !use_result
       end
 
-      attr_reader :singleton, :mid, :mid_code_range
+      attr_reader :singleton, :mid
+
+      def mid_code_range
+        @mid_code_range ||= @lenv.code_range_from_node(@mid_code_range_loc) if @mid_code_range_loc
+      end
       attr_reader :tbl
       attr_reader :req_positionals
       attr_reader :opt_positionals
@@ -168,6 +192,7 @@ module TypeProf::Core
       attr_reader :opt_keywords
       attr_reader :opt_keyword_defaults
       attr_reader :rest_keywords
+      attr_reader :no_keywords
       attr_reader :block
       attr_reader :body
       attr_reader :rbs_method_type
@@ -182,7 +207,6 @@ module TypeProf::Core
       def attrs = {
         singleton:,
         mid:,
-        mid_code_range:,
         tbl:,
         req_positionals:,
         opt_positionals:,
@@ -191,11 +215,12 @@ module TypeProf::Core
         req_keywords:,
         opt_keywords:,
         rest_keywords:,
+        no_keywords:,
         block:,
         reusable:,
       }
 
-      def mname_code_range(_name) = @mid_code_range
+      def mname_code_range(_name) = mid_code_range
 
       def define(genv) # NOT define0
         return define_copy(genv) if @prev_node && @reusable
@@ -219,6 +244,8 @@ module TypeProf::Core
         opt_positionals = @opt_positionals.map {|var| @body.lenv.new_var(var, self) }
         rest_positionals = @rest_positionals ? @body.lenv.new_var(@rest_positionals, self) : nil
         post_positionals = @post_positionals.map {|var| @body.lenv.new_var(var, self) }
+        install_multi_targets(genv, @req_multi_targets, req_positionals)
+        install_multi_targets(genv, @post_multi_targets, post_positionals)
         req_keywords = @req_keywords.map {|var| @body.lenv.new_var(var, self) }
         opt_keywords = @opt_keywords.map {|var| @body.lenv.new_var(var, self) }
         rest_keywords = @rest_keywords ? @body.lenv.new_var(@rest_keywords, self) : nil
@@ -247,6 +274,24 @@ module TypeProf::Core
           block = @body.lenv.new_var(:"*given_block", self)
         end
 
+        forward_opt_positionals = @opt_positionals.map { Vertex.new(self) }
+        forward_rest_positionals = @rest_positionals ? Vertex.new(self) : nil
+        forward_opt_keywords = @opt_keywords.map {|_name| Vertex.new(self) }
+        forward_rest_keywords = @rest_keywords ? Vertex.new(self) : nil
+        forward_block = Vertex.new(self)
+        forward_activation = Vertex.new(self)
+        @body.lenv.forward_args = ForwardingArguments.new(
+          req_positionals,
+          forward_opt_positionals,
+          forward_rest_positionals,
+          post_positionals,
+          @req_keywords.zip(req_keywords),
+          @opt_keywords.zip(forward_opt_keywords),
+          forward_rest_keywords,
+          forward_block,
+          forward_activation,
+        )
+
         if @body
           @body.lenv.locals[:"*expected_method_ret"] = Vertex.new(self)
           @body.install(genv)
@@ -265,10 +310,23 @@ module TypeProf::Core
         )
 
         @changes.add_method_def_box(genv, @lenv.cref.cpath, @singleton, @mid, f_args, @body.lenv.return_boxes)
+        if @lenv.module_function && !@singleton
+          @changes.add_method_def_box(genv, @lenv.cref.cpath, true, @mid, f_args, @body.lenv.return_boxes)
+        end
 
         Source.new(Type::Symbol.new(genv, @mid))
       end
 
+      def install_multi_targets(genv, multi_targets, positionals)
+        multi_targets.each do |idx, raw_multi_target|
+          param_vtx = positionals[idx]
+          lefts = raw_multi_target.lefts.map do |n|
+            @body.lenv.new_var(n.is_a?(Prism::MultiTargetNode) ? nil : n.name, self)
+          end
+          @changes.add_masgn_box(genv, param_vtx, lefts, nil, nil)
+        end
+      end
+
       def last_stmt_code_range
         if @body
           if @body.is_a?(AST::StatementsNode)

data/lib/typeprof/core/ast/misc.rb

@@ -6,7 +6,7 @@ module TypeProf::Core
         stmts = raw_node.body
         @stmts = stmts.map.with_index do |n, i|
           if n
-            AST.create_node(n, lenv, i == stmts.length - 1 ? use_result : false)
+            AST.create_node(n, lenv, i == stmts.length - 1 ? use_result : false, true)
           else
             last = code_range.last
             DummyNilNode.new(TypeProf::CodeRange.new(last, last), lenv)
@@ -256,28 +256,59 @@ module TypeProf::Core
         vtx = @expr.install(genv)
 
         a_args = ActualArguments.new([], [], nil, nil)
-        vtx = @changes.add_method_call_box(genv, vtx, :to_a, a_args, false).ret
-
-        @changes.add_splat_box(genv, vtx).ret
+        # Receiver types with no `to_a` are collected here, so that each union
+        # member can independently fall back to wrapping itself as `[x]`.
+        unresolved_recv = Vertex.new(self)
+        to_a_box = @changes.add_method_call_box(
+          genv,
+          vtx,
+          :to_a,
+          a_args,
+          false,
+          suppress_errors: true,
+          unresolved_recv: unresolved_recv,
+        )
+
+        @changes.add_splat_box(genv, to_a_box.ret, nil, unresolved_recv).ret
       end
     end
 
     class ForNode < Node
       def initialize(raw_node, lenv)
         super(raw_node, lenv)
-        # XXX: tentative implementation
-        # raw_node.index
+        @index = AST.create_target_node(raw_node.index, lenv)
         @expr = AST.create_node(raw_node.collection, lenv)
         @body = raw_node.statements ? AST.create_node(raw_node.statements, lenv) : DummyNilNode.new(TypeProf::CodeRange.new(code_range.last, code_range.last), lenv)
       end
 
-      attr_reader :expr, :body
+      attr_reader :index, :expr, :body
 
-      def subnodes = { expr:, body: }
+      def subnodes = { index:, expr:, body: }
 
       def install0(genv)
         @expr.install(genv)
+
+        vars = []
+        @index.modified_vars(@lenv.locals.keys, vars)
+        @body.modified_vars(@lenv.locals.keys, vars)
+        vars.uniq!
+
+        old_vtxs = {}
+        vars.each do |var|
+          vtx = @lenv.get_var(var)
+          nvtx = vtx.new_vertex(genv, self)
+          old_vtxs[var] = nvtx
+          @lenv.set_var(var, nvtx)
+        end
+
+        @index.install(genv)
         @body.install(genv)
+
+        vars.each do |var|
+          @changes.add_edge(genv, @lenv.get_var(var), old_vtxs[var])
+          @lenv.set_var(var, old_vtxs[var])
+        end
+
         Source.new(genv.nil_type)
       end
     end
@@ -312,8 +343,7 @@ module TypeProf::Core
       def subnodes = { value:, pat: }
 
       def install0(genv)
-        @value.install(genv)
-        @pat.install(genv)
+        @pat.install_pattern(genv, @value.install(genv))
         Source.new(genv.nil_type)
       end
     end
@@ -330,8 +360,7 @@ module TypeProf::Core
       def subnodes = { value:, pat: }
 
       def install0(genv)
-        @value.install(genv)
-        @pat.install(genv)
+        @pat.install_pattern(genv, @value.install(genv))
         Source.new(genv.true_type, genv.false_type)
       end
     end

data/lib/typeprof/core/ast/module.rb

@@ -12,17 +12,21 @@ module TypeProf::Core
 
         if @static_cpath
           ncref = CRef.new(@static_cpath, meta ? :metaclass : :class, nil, lenv.cref)
-          nlenv = LocalEnv.new(@lenv.path, ncref, {}, [])
+          nlenv = LocalEnv.new(@lenv.file_context, ncref, {}, [])
           @body = raw_scope ? AST.create_node(raw_scope, nlenv, use_result) : DummyNilNode.new(code_range, lenv)
         else
           @body = nil
         end
 
-        @cname_code_range = meta ? nil : TypeProf::CodeRange.from_node(raw_node.constant_path)
+        @cname_code_range_loc = meta ? nil : raw_node.constant_path
         @mod_cdef = nil
       end
 
-      attr_reader :tbl, :cpath, :static_cpath, :cname_code_range, :body
+      attr_reader :tbl, :cpath, :static_cpath, :body
+
+      def cname_code_range
+        @cname_code_range ||= @lenv.code_range_from_node(@cname_code_range_loc) if @cname_code_range_loc
+      end
 
       def subnodes = { cpath:, body: }
       def attrs = { static_cpath:, tbl: }
@@ -89,7 +93,22 @@ module TypeProf::Core
       def initialize(raw_node, lenv, use_result)
         super(raw_node, lenv, raw_node.constant_path, false, raw_node.body, use_result)
         raw_superclass = raw_node.superclass
-        @superclass_cpath = raw_superclass ? AST.create_node(raw_superclass, lenv) : nil
+        if raw_superclass
+          # In Ruby, the superclass expression is evaluated before the class constant
+          # is created. When the superclass is a bare constant with the same name as
+          # the class being defined (e.g., `class Foo < Foo` inside a module), use the
+          # outer scope to avoid resolving to the class itself.
+          if @static_cpath && lenv.cref.outer &&
+             raw_superclass.type == :constant_read_node &&
+             raw_superclass.name == @static_cpath.last
+            slenv = LocalEnv.new(lenv.file_context, lenv.cref.outer, {}, [])
+            @superclass_cpath = AST.create_node(raw_superclass, slenv)
+          else
+            @superclass_cpath = AST.create_node(raw_superclass, lenv)
+          end
+        else
+          @superclass_cpath = nil
+        end
       end
 
       attr_reader :superclass_cpath
@@ -113,6 +132,21 @@ module TypeProf::Core
 
       def install0(genv)
         @superclass_cpath.install(genv) if @superclass_cpath
+        if @static_cpath && @superclass_cpath
+          const_read = @superclass_cpath.static_ret
+          if const_read && const_read.cpath
+            super_mod = genv.resolve_cpath(const_read.cpath)
+            self_mod = genv.resolve_cpath(@static_cpath)
+            mod = super_mod
+            while mod
+              if mod == self_mod
+                @changes.add_diagnostic(:code_range, "circular inheritance", @superclass_cpath)
+                break
+              end
+              mod = mod.superclass
+            end
+          end
+        end
         super(genv)
       end
     end

data/lib/typeprof/core/ast/pattern.rb

@@ -22,14 +22,19 @@ module TypeProf::Core
       def attrs = { rest: }
       def subnodes = { requireds:, rest_pattern:, posts: }
 
-      def install0(genv)
-        @requireds.each do |pat|
-          pat.install(genv)
+      def install_pattern0(genv, subject)
+        @requireds.each_with_index do |pat, i|
+          pat.install_pattern(genv, @changes.add_splat_box(genv, subject, i).ret)
+        end
+        if @rest_pattern
+          elem = @changes.add_splat_box(genv, subject).ret
+          @rest_pattern.install_pattern(genv, Source.new(genv.gen_ary_type(elem)))
         end
-        @rest_pattern.install(genv) if @rest_pattern
         @posts.each do |pat|
-          pat.install(genv)
+          # TODO: precise indices for post elements (those after `*rest`)
+          pat.install_pattern(genv, @changes.add_splat_box(genv, subject).ret)
         end
+        subject
       end
     end
 
@@ -39,7 +44,14 @@ module TypeProf::Core
         @keys = raw_node.elements.map {|raw_assoc| raw_assoc.key.value.to_sym }
         @values = raw_node.elements.map {|raw_assoc| AST.create_pattern_node(raw_assoc.value, lenv) }
         @rest = !!raw_node.rest
-        @rest_pattern = raw_node.rest && raw_node.rest.value ? AST.create_pattern_node(raw_node.rest.value, lenv) : nil
+        @rest_pattern = case raw_node.rest
+                        when Prism::AssocSplatNode
+                          AST.create_pattern_node(raw_node.rest.value, lenv) if raw_node.rest.value
+                        when Prism::NoKeywordsParameterNode, nil
+                          nil
+                        else
+                          raise
+                        end
       end
 
       attr_reader :keys, :values, :rest, :rest_pattern
@@ -47,32 +59,37 @@ module TypeProf::Core
       def attrs = { keys:, rest: }
       def subnodes = { values:, rest_pattern: }
 
-      def install0(genv)
+      def install_pattern0(genv, subject)
+        # TODO: extract each key's value type from `subject` (captures stay untyped for now)
         @values.each do |pat|
-          pat.install(genv)
+          pat.install_pattern(genv, Vertex.new(self))
         end
-        @rest_pattern.install(genv) if @rest_pattern
+        @rest_pattern.install_pattern(genv, Vertex.new(self)) if @rest_pattern
+        subject
       end
     end
 
     class FindPatternNode < Node
       def initialize(raw_node, lenv)
         super(raw_node, lenv)
-        @left = raw_node.left ? AST.create_pattern_node(raw_node.left.expression, lenv) : nil
+        @left = raw_node.left.expression ? AST.create_pattern_node(raw_node.left.expression, lenv) : nil
         @requireds = raw_node.requireds.map {|raw_elem| AST.create_pattern_node(raw_elem, lenv) }
-        @right = raw_node.right ? AST.create_pattern_node(raw_node.right.expression, lenv) : nil
+        @right = raw_node.right.expression ? AST.create_pattern_node(raw_node.right.expression, lenv) : nil
       end
 
       attr_reader :left, :requireds, :right
 
       def subnodes = { left:, requireds:, right: }
 
-      def install0(genv)
-        @left.install(genv) if @left
+      def install_pattern0(genv, subject)
+        elem = @changes.add_splat_box(genv, subject).ret
+        rest_ary = Source.new(genv.gen_ary_type(elem))
+        @left.install_pattern(genv, rest_ary) if @left
         @requireds.each do |pat|
-          pat.install(genv)
+          pat.install_pattern(genv, elem)
         end
-        @right.install(genv) if @right
+        @right.install_pattern(genv, rest_ary) if @right
+        subject
       end
     end
 
@@ -87,9 +104,10 @@ module TypeProf::Core
 
       def subnodes = { left:, right: }
 
-      def install0(genv)
-        @left.install(genv)
-        @right.install(genv)
+      def install_pattern0(genv, subject)
+        @left.install_pattern(genv, subject)
+        @right.install_pattern(genv, subject)
+        subject
       end
     end
 
@@ -104,9 +122,18 @@ module TypeProf::Core
 
       def subnodes = { value:, target: }
 
-      def install0(genv)
-        @value.install(genv)
-        @target.install(genv)
+      def install_pattern0(genv, subject)
+        @value.install_pattern(genv, subject)
+        # For `Const => var`, narrow the capture by the class, as `when Const` does
+        narrowed =
+          if @value.is_a?(ConstantReadNode) && @value.static_ret
+            filtered = subject.new_vertex(genv, self)
+            IsAFilter.new(genv, self, filtered, false, @value.static_ret).next_vtx
+          else
+            subject
+          end
+        @target.install_pattern(genv, narrowed)
+        subject
       end
     end
 
@@ -124,9 +151,10 @@ module TypeProf::Core
 
       def subnodes = { cond:, body: }
 
-      def install0(genv)
+      def install_pattern0(genv, subject)
         @cond.install(genv)
-        @body.install(genv)
+        @body.install_pattern(genv, subject)
+        subject
       end
     end