Fix the arguments and the lookup of super

lib/typeprof/core/ast/call.rb

@@ -2,11 +2,15 @@ module TypeProf::Core
   class AST
     # @lenv is the scope the block closes over; the body has its own LocalEnv.
     class BlockNode < Node
-      def initialize(raw_node, lenv, mid)
+      def initialize(raw_node, lenv, method_body: false)
         super(raw_node, lenv)
 
         @tbl = raw_node.locals
-        ncref = CRef.new(lenv.cref.cpath, :instance, mid, lenv.cref)
+        @method_body = method_body
+        # A `super` in a block calls the super of the enclosing method, but a
+        # block given to define_method is the body of another method, whose name
+        # is not known here
+        ncref = CRef.new(lenv.cref.cpath, :instance, method_body ? nil : lenv.cref.mid, lenv.cref)
         # A `return` in a block exits the enclosing method, so the body writes into
         # its return boxes. A lambda's `return` exits the lambda, so it gets its own.
         nlenv = LocalEnv.new(lenv.file_context, ncref, {}, lambda? ? [] : lenv.return_boxes)
@@ -60,7 +64,11 @@ def formal_names
 
       def install0(genv)
         blenv = @body.lenv
-        blenv.forward_args = @lenv.forward_args
+        # Ruby rejects a bare `super` in a define_method block at runtime
+        blenv.forward_args = @lenv.forward_args unless @method_body
+        # An outer block may have shadowed the same name already; its entry is
+        # the method's variable, so it must win over the outer block's own one
+        blenv.shadowed_vars = @lenv.locals.slice(*@tbl).merge(@lenv.shadowed_vars)
         @lenv.locals.each {|var, vtx| blenv.locals[var] = vtx }
         @tbl.each {|var| blenv.locals[var] = Source.new(genv.nil_type) }
         blenv.locals[:"*self"] = blenv.cref.get_self(genv)
@@ -140,6 +148,8 @@ def ret_code_range = @body.ret_code_range
     end
 
     class CallBaseNode < Node
+      DEFINE_METHOD_MIDS = [:define_method, :define_singleton_method].freeze
+
       def initialize(raw_node, recv, mid, mid_code_range_loc, raw_args, last_arg, raw_block, lenv, forwarding_arguments: false)
         super(raw_node, lenv)
 
@@ -191,7 +201,7 @@ def initialize(raw_node, recv, mid, mid_code_range_loc, raw_args, last_arg, raw_
               @anonymous_block_forwarding = true
             end
           else
-            @block = BlockNode.new(raw_block, lenv, @mid)
+            @block = BlockNode.new(raw_block, lenv, method_body: DEFINE_METHOD_MIDS.include?(@mid))
           end
         end
 
@@ -225,13 +235,12 @@ def install0(genv)
         end
 
         if forward_args
-          forward_a_args = forward_args.to_actual_arguments(
-            genv,
-            @changes,
-            self,
-            include_leading_positionals: @forwarding_arguments != :rest,
-            activation_required: @forwarding_arguments == :rest,
-          )
+          forward_a_args =
+            if @forwarding_arguments == :all
+              forward_args.to_implicit_super_arguments(genv, @changes, self, @lenv)
+            else
+              forward_args.to_actual_arguments(genv, @changes, self)
+            end
           # An anonymous rest cannot appear here: `bar(*, ...)` is a syntax error
           leading_args = @positional_args.map {|arg| arg.install(genv) }
           a_args = forward_a_args.prepend_positionals(leading_args, @splat_flags)

lib/typeprof/core/ast/method.rb

@@ -300,6 +300,17 @@ def install0(genv)
           forward_rest_keywords,
           forward_block,
           forward_activation,
+          {
+            req_positionals: @req_positionals,
+            opt_positionals: @opt_positionals,
+            # The variables of `...` and anonymous parameters hold only a
+            # placeholder, so what the caller passed is forwarded instead
+            rest_positionals: [:"...", :"*anonymous_rest"].include?(@rest_positionals) ? nil : @rest_positionals,
+            post_positionals: @post_positionals,
+            req_keywords: @req_keywords,
+            opt_keywords: @opt_keywords,
+            rest_keywords: [:"...", :"**anonymous_keyword"].include?(@rest_keywords) ? nil : @rest_keywords,
+          },
         )
 
         if @body

lib/typeprof/core/ast/value.rb

@@ -330,10 +330,6 @@ def install0(genv)
     # A lambda literal is a block without a call: `->` never dispatches to a
     # user-defined `lambda` method.
     class LambdaNode < BlockNode
-      def initialize(raw_node, lenv)
-        super(raw_node, lenv, lenv.cref.mid)
-      end
-
       def lambda? = true
 
       # A lambda is entered like a method, so every parameter kind binds, not just

lib/typeprof/core/env.rb

@@ -374,12 +374,13 @@ def initialize(file_context, cref, locals, return_boxes, forward_args = nil, sig
       @ivar_narrowings = {}
       @strict_const_scope = false
       @forward_args = forward_args
+      @shadowed_vars = {}
       # [cpath, names] of the type parameters of the enclosing RBS declaration
       @sig_type_params = sig_type_params
     end
 
     attr_reader :file_context, :cref, :locals, :return_boxes, :break_vtx, :next_boxes, :strict_const_scope, :sig_type_params
-    attr_accessor :module_function, :forward_args
+    attr_accessor :module_function, :forward_args, :shadowed_vars
 
     def path = @file_context&.path
     def code_range_from_node(node)
@@ -398,6 +399,12 @@ def get_var(name)
       @locals[name] || raise("#{ name }")
     end
 
+    # A bare `super` passes the variables of the method, not the block
+    # parameters that shadow them
+    def get_method_var(name)
+      @shadowed_vars[name] || get_var(name)
+    end
+
     def exist_var?(name)
       !!@locals[name]
     end

lib/typeprof/core/env/method.rb

@@ -384,7 +384,7 @@ def empty_omittable_splat_argument?(genv, arg)
   end
 
   class ForwardingArguments
-    def initialize(req_positionals, opt_positionals, rest_positionals, post_positionals, req_keyword_pairs, opt_keyword_pairs, rest_keywords, block, activation)
+    def initialize(req_positionals, opt_positionals, rest_positionals, post_positionals, req_keyword_pairs, opt_keyword_pairs, rest_keywords, block, activation, param_names)
       @req_positionals = req_positionals
       @opt_positionals = opt_positionals
       @rest_positionals = rest_positionals
@@ -394,12 +394,14 @@ def initialize(req_positionals, opt_positionals, rest_positionals, post_position
       @rest_keywords = rest_keywords
       @block = block
       @activation = activation
+      @param_names = param_names
     end
 
-    def to_actual_arguments(genv, changes, node, include_leading_positionals: true, activation_required: false)
-      positionals = include_leading_positionals ? @req_positionals.dup : []
-      splat_flags = ::Array.new(positionals.size, false)
-      positionals_omittable = ::Array.new(positionals.size, false)
+    # The arguments that `...` forwards: only the ones the caller passed.
+    def to_actual_arguments(genv, changes, node)
+      positionals = []
+      splat_flags = []
+      positionals_omittable = []
 
       @opt_positionals.each do |elem_vtx|
         positionals << Source.new(genv.gen_ary_type(elem_vtx))
@@ -419,8 +421,51 @@ def to_actual_arguments(genv, changes, node, include_leading_positionals: true,
         positionals_omittable << false
       end
 
-      keywords, keywords_omittable = build_keyword_args(genv, changes, node)
-      ForwardingActualArguments.new(positionals, splat_flags, keywords, @block, positionals_omittable, keywords_omittable, true, @activation, activation_required)
+      # `...` cannot follow keyword parameters, so only the rest keywords remain
+      ForwardingActualArguments.new(positionals, splat_flags, @rest_keywords, @block, positionals_omittable, !!@rest_keywords, true, @activation, true)
+    end
+
+    # A bare `super` passes the current values of the parameters, which
+    # include the defaults of omitted ones and any reassignment.
+    def to_implicit_super_arguments(genv, changes, node, lenv)
+      positionals = []
+      splat_flags = []
+      positionals_omittable = []
+
+      # A destructured parameter has no name, so it is passed as it was given
+      @param_names[:req_positionals].zip(@req_positionals) do |name, vtx|
+        positionals << (name ? lenv.get_method_var(name) : vtx)
+        splat_flags << false
+        positionals_omittable << false
+      end
+
+      @param_names[:opt_positionals].each do |name|
+        positionals << lenv.get_method_var(name)
+        splat_flags << false
+        positionals_omittable << false
+      end
+
+      if @param_names[:rest_positionals]
+        positionals << lenv.get_method_var(@param_names[:rest_positionals])
+        splat_flags << true
+        positionals_omittable << true
+      elsif @rest_positionals
+        positionals << Source.new(genv.gen_ary_type(@rest_positionals))
+        splat_flags << true
+        positionals_omittable << true
+      end
+
+      @param_names[:post_positionals].zip(@post_positionals) do |name, vtx|
+        positionals << (name ? lenv.get_method_var(name) : vtx)
+        splat_flags << false
+        positionals_omittable << false
+      end
+
+      req_keyword_pairs = @param_names[:req_keywords].map {|name| [name, lenv.get_method_var(name)] }
+      opt_keyword_pairs = @param_names[:opt_keywords].map {|name| [name, lenv.get_method_var(name)] }
+      rest_keywords = @param_names[:rest_keywords] ? lenv.get_method_var(@param_names[:rest_keywords]) : @rest_keywords
+      keywords, keywords_omittable = build_keyword_args(genv, changes, node, req_keyword_pairs, opt_keyword_pairs, rest_keywords)
+      ForwardingActualArguments.new(positionals, splat_flags, keywords, @block, positionals_omittable, keywords_omittable, true, @activation, false)
     end
 
     def accept_actual_arguments(genv, changes, a_args)
@@ -525,18 +570,16 @@ def accept_actual_arguments(genv, changes, a_args)
 
     private
 
-    def build_keyword_args(genv, changes, node)
-      opt_keyword_pairs = @opt_keyword_pairs
-
-      if @req_keyword_pairs.empty? && opt_keyword_pairs.empty?
-        return @rest_keywords, !!@rest_keywords
+    def build_keyword_args(genv, changes, node, req_keyword_pairs, opt_keyword_pairs, rest_keywords)
+      if req_keyword_pairs.empty? && opt_keyword_pairs.empty?
+        return rest_keywords, !!rest_keywords
       end
 
       unified_key = Vertex.new(node)
       unified_val = Vertex.new(node)
       literal_pairs = {}
 
-      @req_keyword_pairs.each do |name, vtx|
+      req_keyword_pairs.each do |name, vtx|
         changes.add_edge(genv, Source.new(Type::Symbol.new(genv, name)), unified_key)
         changes.add_edge(genv, vtx, unified_val)
         literal_pairs[name] = vtx
@@ -549,13 +592,13 @@ def build_keyword_args(genv, changes, node)
       end
 
       base_hash_type = genv.gen_hash_type(unified_key, unified_val)
-      changes.add_hash_splat_box(genv, @rest_keywords, unified_key, unified_val) if @rest_keywords
+      changes.add_hash_splat_box(genv, rest_keywords, unified_key, unified_val) if rest_keywords
 
       if literal_pairs.empty?
         [Source.new(base_hash_type), false]
-      elsif @rest_keywords
+      elsif rest_keywords
         fallback = Source.new(Type::Record.new(genv, literal_pairs, base_hash_type))
-        [changes.add_keyword_merge_box(genv, @rest_keywords, literal_pairs, fallback).ret, false]
+        [changes.add_keyword_merge_box(genv, rest_keywords, literal_pairs, fallback).ret, false]
       else
         [Source.new(Type::Record.new(genv, literal_pairs, base_hash_type)), false]
       end

lib/typeprof/core/graph/box.rb

@@ -680,6 +680,8 @@ def initialize(node, genv, rest, literal_pairs, fallback)
       @fallback = fallback
       @rest.add_edge(genv, self)
       @ret = Vertex.new(node)
+      # An empty rest never triggers a run, but the fallback still has to flow
+      genv.add_run(self)
     end
 
     attr_reader :ret
@@ -1025,6 +1027,8 @@ def resolve(genv, changes, &blk)
         next if orig_ty == genv.bot_type
         if @mid == :"*super"
           mid = @node.lenv.cref.mid
+          # Outside a method or in a define_method block, the method is unknown
+          next unless mid
           skip = true
         else
           mid = @mid

scenario/diagnostics/super-outside-method.rb

@@ -6,4 +6,24 @@
 ## diagnostics
 (1,0)-(1,13): undefined method: Object#define_method
 (2,2)-(2,7): implicit argument passing of super is not supported here
-(2,2)-(2,7): undefined method: Object#define_method
+
+## update
+class Foo
+  define_method(:foo) { super() }
+end
+
+## diagnostics
+
+## update
+class Base
+  def bar = 1
+end
+class Foo < Base
+  def self.make
+    define_method(:bar) { super() }
+    define_singleton_method(:baz) { super }
+  end
+end
+
+## diagnostics
+(7,36)-(7,41): implicit argument passing of super is not supported here