typeprof 0.33.0 → 0.33.2

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

@@ -16,6 +16,8 @@ module TypeProf::Core
 
       attr_reader :stmts
 
+      def ret_code_range = @stmts.last.code_range
+
       def subnodes = { stmts: }
 
       def install0(genv)
@@ -23,8 +25,13 @@ module TypeProf::Core
 
         post_stmts = []
 
+        # BEGIN runs before the surrounding statements, END after them
+        @stmts.each do |stmt|
+          stmt.install(genv) if stmt.is_a?(PreExecutionNode)
+        end
+
         @stmts.each do |stmt|
-          next if stmt.nil?
+          next if stmt.is_a?(PreExecutionNode)
 
           if stmt.is_a?(PostExecutionNode)
             post_stmts << stmt
@@ -126,7 +133,7 @@ module TypeProf::Core
         if @rights
           @rights.each {|lhs| lhs.install(genv) }
           @rights.each {|lhs| lhs.rhs.ret || raise(lhs.rhs.inspect) }
-          rights = @rights.map {|rhs| rhs.ret }
+          rights = @rights.map {|lhs| lhs.rhs.ret }
         end
 
         box = @changes.add_masgn_box(genv, value, lefts, rest_elem, rights)

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

@@ -144,7 +144,8 @@ module TypeProf::Core
         raise if raw_node.statements.type != :statements_node
         raise if raw_node.statements.body.size != 1
         @body = AST.create_pattern_node(raw_node.statements.body[0], lenv)
-        raise if raw_node.subsequent
+        raise if raw_node.type == :if_node && raw_node.subsequent
+        raise if raw_node.type == :unless_node && raw_node.else_clause
       end
 
       attr_reader :cond, :body
@@ -152,8 +153,9 @@ module TypeProf::Core
       def subnodes = { cond:, body: }
 
       def install_pattern0(genv, subject)
-        @cond.install(genv)
+        # The guard is evaluated after the pattern binds its variables
         @body.install_pattern(genv, subject)
+        @cond.install(genv)
         subject
       end
     end

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

@@ -14,16 +14,20 @@ module TypeProf::Core
         @cpath = AST.resolve_rbs_name(raw_decl.name, lenv)
         # TODO: decl.type_params
         # TODO: decl.super_class.args
+        # TODO?: param.variance, param.unchecked, param.upper_bound
+        @params = raw_decl.type_params.map {|param| param.name }
+        sig_type_params = [@cpath, @params]
+        # The header (default types, self types, and superclass arguments) is
+        # resolved in the outer scope but may refer to the type parameters
+        @header_lenv = LocalEnv.new(@lenv.file_context, lenv.cref, {}, [], sig_type_params:)
         ncref = CRef.new(@cpath, :class, nil, lenv.cref)
-        nlenv = LocalEnv.new(@lenv.file_context, ncref, {}, [])
+        nlenv = LocalEnv.new(@lenv.file_context, ncref, {}, [], sig_type_params:)
         @members = raw_decl.members.map do |member|
           AST.create_rbs_member(member, nlenv)
         end.compact
-        # TODO?: param.variance, param.unchecked, param.upper_bound
-        @params = raw_decl.type_params.map {|param| param.name }
         @params_default_types = raw_decl.type_params.map do |param|
           ty = param.default_type
-          ty ? AST.create_rbs_type(ty, lenv) : nil
+          ty ? AST.create_rbs_type(ty, @header_lenv) : nil
         end
       end
 
@@ -81,7 +85,7 @@ module TypeProf::Core
           cpath = name.namespace.path + [self_type.name.name]
           toplevel = name.namespace.absolute?
           @self_types << [cpath, toplevel]
-          @self_type_args << self_type.args.map {|arg| AST.create_rbs_type(arg, lenv) }
+          @self_type_args << self_type.args.map {|arg| AST.create_rbs_type(arg, @header_lenv) }
         end
       end
 
@@ -138,7 +142,7 @@ module TypeProf::Core
           name = superclass.name
           @superclass_cpath = name.namespace.path + [name.name]
           @superclass_toplevel = name.namespace.absolute?
-          @superclass_args = superclass.args.map {|arg| AST.create_rbs_type(arg, lenv) }
+          @superclass_args = superclass.args.map {|arg| AST.create_rbs_type(arg, @header_lenv) }
         else
           @superclass_cpath = nil
           @superclass_toplevel = nil

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

@@ -39,7 +39,7 @@ module TypeProf::Core
         if prep_decl.is_a?(AST::SigPrependNode) && prep_mod.type_params
           prep_ty = genv.get_instance_type(prep_mod, prep_decl.args, changes, {}, a_ty)
         else
-          type_params = prep_mod.type_params.map {|(_name, _default_ty)| Source.new() } # TODO: better support
+          type_params = prep_mod.type_params.map {|(_name, _default_ty)| genv.untyped_arg } # TODO: better support
           prep_ty = Type::Instance.new(genv, prep_mod, type_params)
         end
         if prep_ty.mod == f_mod
@@ -64,7 +64,7 @@ module TypeProf::Core
         if inc_decl.is_a?(AST::SigIncludeNode) && inc_mod.type_params
           inc_ty = genv.get_instance_type(inc_mod, inc_decl.args, changes, {}, a_ty)
         else
-          type_params = inc_mod.type_params.map {|(_name, _default_ty)| Source.new() } # TODO: better support
+          type_params = inc_mod.type_params.map {|(_name, _default_ty)| genv.untyped_arg } # TODO: better support
           inc_ty = Type::Instance.new(genv, inc_mod, type_params)
         end
         if inc_ty.mod == f_mod
@@ -89,7 +89,7 @@ module TypeProf::Core
         if ext_decl.is_a?(AST::SigExtendNode) && ext_mod.type_params
           ext_ty = genv.get_instance_type(ext_mod, ext_decl.args, changes, {}, a_ty)
         else
-          type_params = ext_mod.type_params.map {|(_name, _default_ty)| Source.new() } # TODO: better support
+          type_params = ext_mod.type_params.map {|(_name, _default_ty)| genv.untyped_arg } # TODO: better support
           ext_ty = Type::Instance.new(genv, ext_mod, type_params)
         end
         if ext_ty.mod == f_mod
@@ -705,6 +705,10 @@ module TypeProf::Core
         return unless cpath
         mod = genv.resolve_cpath(cpath)
         args = @args.map {|arg| arg.covariant_vertex(genv, changes, subst) }
+        # Omitted type arguments (e.g., `Foo` for `Foo[T]`) default to untyped
+        mod.type_params.drop(args.size).each do |_, default_ty|
+          args << (default_ty ? default_ty.covariant_vertex(genv, changes, subst) : genv.untyped_arg)
+        end
         changes.add_edge(genv, Source.new(Type::Instance.new(genv, mod, args)), vtx)
       end
 
@@ -716,7 +720,7 @@ module TypeProf::Core
         # TODO: report error for wrong type arguments
         # TODO: support default type args
         args = mod.type_params.zip(@args).map do |_, arg|
-          arg ? arg.contravariant_vertex(genv, changes, subst) : Source.new
+          arg ? arg.contravariant_vertex(genv, changes, subst) : genv.untyped_arg
         end
         changes.add_edge(genv, Source.new(Type::Instance.new(genv, mod, args)), vtx)
       end
@@ -883,18 +887,32 @@ module TypeProf::Core
 
       def attrs = { var: }
 
+      # A reopened declaration may rename the type parameters (e.g., `Enumerable[E]`
+      # and `Enumerable[Elem]`), but the subst is keyed by the names of the module
+      # entity, so fall back to matching them by position
+      def resolve_var(genv, subst)
+        decl_cpath, decl_params = @lenv.sig_type_params
+        return subst[@var] unless decl_params
+        idx = decl_params.index(@var)
+        return subst[@var] unless idx
+        subst[genv.resolve_cpath(decl_cpath).type_params.keys[idx]]
+      end
+
       def covariant_vertex0(genv, changes, vtx, subst)
-        raise "unknown type variable: #{ @var }" unless subst[@var]
-        changes.add_edge(genv, subst[@var], vtx)
+        var_vtx = resolve_var(genv, subst)
+        raise "unknown type variable: #{ @var }" unless var_vtx
+        changes.add_edge(genv, var_vtx, vtx)
       end
 
       def contravariant_vertex0(genv, changes, vtx, subst)
-        raise "unknown type variable: #{ @var }" unless subst[@var]
-        changes.add_edge(genv, Source.new(Type::Var.new(genv, @var, subst[@var])), vtx)
+        var_vtx = resolve_var(genv, subst)
+        raise "unknown type variable: #{ @var }" unless var_vtx
+        changes.add_edge(genv, Source.new(Type::Var.new(genv, @var, var_vtx)), vtx)
       end
 
       def typecheck(genv, changes, vtx, subst)
-        changes.add_edge(genv, vtx.new_vertex(genv, self), subst[@var]) unless vtx == subst[@var]
+        var_vtx = resolve_var(genv, subst)
+        changes.add_edge(genv, vtx.new_vertex(genv, self), var_vtx) unless vtx == var_vtx
         true
       end
 
@@ -1081,6 +1099,10 @@ module TypeProf::Core
         return unless cpath
         mod = genv.resolve_cpath(cpath)
         args = @args.map {|arg| arg.covariant_vertex(genv, changes, subst) }
+        # Omitted type arguments (e.g., `Foo` for `Foo[T]`) default to untyped
+        mod.type_params.drop(args.size).each do |_, default_ty|
+          args << (default_ty ? default_ty.covariant_vertex(genv, changes, subst) : genv.untyped_arg)
+        end
         changes.add_edge(genv, Source.new(Type::Instance.new(genv, mod, args)), vtx)
       end
 
@@ -1090,6 +1112,7 @@ module TypeProf::Core
         return unless cpath
         mod = genv.resolve_cpath(cpath)
         args = @args.map {|arg| arg.contravariant_vertex(genv, changes, subst) }
+        mod.type_params.drop(args.size).each { args << genv.untyped_arg }
         changes.add_edge(genv, Source.new(Type::Instance.new(genv, mod, args)), vtx)
       end
 

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

@@ -326,10 +326,59 @@ module TypeProf::Core
       end
     end
 
-    class LambdaNode < Node
-      def install0(genv)
-        Source.new(genv.proc_type)
+    # Prism::LambdaNode has the same locals/parameters/body as Prism::BlockNode.
+    # A lambda literal is a block without a call: `->` never dispatches to a
+    # user-defined `lambda` method.
+    class LambdaNode < BlockNode
+      def lambda? = true
+
+      # A diagnostic on the `===` call below, such as wrong arity, points at the
+      # whole lambda.
+      def mid_code_range = nil
+
+      # `in ->(x) { ... }` matches by calling the lambda with the subject.
+      def install_pattern0(genv, subject)
+        recv = install0(genv)
+        a_args = ActualArguments.new([subject], [false], nil, nil)
+        @changes.add_method_call_box(genv, recv, :===, a_args, false)
+        recv
       end
+
+      # A lambda is entered like a method, so every parameter kind binds, not just
+      # the positionals a block is handed.
+      def build_formals(genv, blenv, f_args)
+        # f_args is the block-shaped list, required then optional; numbered and `it`
+        # parameters put names there that @params does not carry.
+        req_count = f_args.size - @opt_positional_defaults.size
+        rest = new_formal(blenv, @params[:rest_positionals])
+        post = @params[:post_positionals].map {|v| blenv.new_var(v, self) }
+        req_keywords = self.req_keywords.map {|v| blenv.new_var(v, self) }
+        opt_keywords = self.opt_keywords.map {|v| blenv.new_var(v, self) }
+        rest_keywords = new_formal(blenv, self.rest_keywords)
+        block = new_formal(blenv, @params[:block])
+
+        if rest
+          @changes.add_edge(genv, Source.new(genv.gen_ary_type(Vertex.new(self))), rest)
+        end
+        # Only the anonymous `**` needs seeding, as it does for a method: a named
+        # one takes its type from what the call passes.
+        if self.rest_keywords == :"**anonymous_keyword"
+          @changes.add_edge(genv, Source.new(genv.gen_hash_type(Vertex.new(self), Vertex.new(self))), rest_keywords)
+        end
+        install_multi_targets(genv, @params[:post_multi_targets], post, blenv)
+        opt_keyword_defaults.zip(opt_keywords) do |expr, vtx|
+          @changes.add_edge(genv, expr.install(genv), vtx)
+        end
+
+        FormalArguments.new(
+          f_args[0, req_count], f_args[req_count..], rest, post,
+          req_keywords, opt_keywords, rest_keywords, block,
+        )
+      end
+
+      private
+
+      def new_formal(blenv, name) = name ? blenv.new_var(name, self) : nil
     end
   end
 end

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

@@ -257,7 +257,7 @@ module TypeProf::Core
       end
     end
 
-    class PostExecutionNode < Node
+    class ExecutionBaseNode < Node
       def initialize(raw_node, lenv)
         super(raw_node, lenv)
         @body = raw_node.statements ? AST.create_node(raw_node.statements, lenv) : DummyNilNode.new(TypeProf::CodeRange.new(code_range.last, code_range.last), lenv)
@@ -273,6 +273,12 @@ module TypeProf::Core
       end
     end
 
+    class PreExecutionNode < ExecutionBaseNode
+    end
+
+    class PostExecutionNode < ExecutionBaseNode
+    end
+
     class ClassVariableWriteNode < Node
       def initialize(raw_node, rhs, lenv)
         super(raw_node, lenv)

data/lib/typeprof/core/ast.rb

@@ -1,14 +1,24 @@
 module TypeProf::Core
   class AST
     def self.parse_rb(path, src, position_encoding)
-      result = Prism.parse(src)
+      build_rb(path, Prism.parse(src), position_encoding)
+    end
+
+    # This needs the comments and the Prism::Source, which a ParseResult has but a
+    # node does not.
+    def self.build_rb(path, result, position_encoding)
+      unless result.is_a?(Prism::ParseResult)
+        raise ArgumentError, "expected Prism::ParseResult, got #{ result.class }"
+      end
 
       return nil unless result.errors.empty?
 
       # comments, errors, magic_comments
       raw_scope = result.value
 
-      raise unless raw_scope.type == :program_node
+      unless raw_scope.is_a?(Prism::ProgramNode)
+        raise ArgumentError, "expected Prism::ProgramNode, got #{ raw_scope.class }"
+      end
 
       prism_source = result.source
       file_context = FileContext.new(path, position_encoding, prism_source, result.comments)
@@ -268,6 +278,7 @@ module TypeProf::Core
       when :splat_node then SplatNode.new(raw_node, lenv)
       when :for_node then ForNode.new(raw_node, lenv)
       when :alias_global_variable_node then AliasGlobalVariableNode.new(raw_node, lenv)
+      when :pre_execution_node then PreExecutionNode.new(raw_node, lenv)
       when :post_execution_node then PostExecutionNode.new(raw_node, lenv)
       when :flip_flop_node then FlipFlopNode.new(raw_node, lenv)
       when :shareable_constant_node then create_node(raw_node.write, lenv)
@@ -352,7 +363,7 @@ module TypeProf::Core
 
       when :capture_pattern_node then CapturePatternNode.new(raw_node, lenv)
 
-      when :if_node then IfPatternNode.new(raw_node, lenv)
+      when :if_node, :unless_node then IfPatternNode.new(raw_node, lenv)
 
       when :pinned_variable_node then PinnedPatternNode.new(raw_node, lenv)
       when :pinned_expression_node then PinnedPatternNode.new(raw_node, lenv)
@@ -386,6 +397,7 @@ module TypeProf::Core
 
       when :array_node then ArrayNode.new(raw_node, lenv) # for %w[foo bar]
       when :range_node then RangeNode.new(raw_node, lenv) # TODO: support range pattern correctly
+      when :lambda_node then LambdaNode.new(raw_node, lenv)
 
       else
         raise "unknown pattern node type: #{ raw_node.type }"

data/lib/typeprof/core/builtin.rb

@@ -25,7 +25,7 @@ module TypeProf::Core
     def proc_call(changes, node, ty, a_args, ret)
       case ty
       when Type::Proc
-        ty.block.accept_args(@genv, changes, a_args.positionals)
+        ty.block.pass_arguments(@genv, changes, a_args)
         ty.block.add_ret(@genv, changes, ret)
         true
       else

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

@@ -21,6 +21,136 @@ module TypeProf::Core
     attr_reader :opt_keywords
     attr_reader :rest_keywords
     attr_reader :block
+
+    # Binds a call's actual arguments to these formals. `node` supplies the
+    # keyword names, which live on the AST node rather than in the vertices.
+    def pass_arguments(changes, genv, a_args, node)
+      if a_args.splat_flags.any?
+        # there is at least one splat actual argument
+
+        lower = @req_positionals.size + @post_positionals.size
+        upper = @rest_positionals ? nil : lower + @opt_positionals.size
+        if upper && upper < a_args.positionals.size
+          meth = changes.node.mid_code_range ? :mid_code_range : :code_range
+          err = "#{ a_args.positionals.size } for #{ lower }#{ upper ? lower < upper ? "...#{ upper }" : "" : "+" }"
+          changes.add_diagnostic(meth, "wrong number of arguments (#{ err })")
+          return false
+        end
+
+        start_rest = [a_args.splat_flags.index(true), @req_positionals.size + @opt_positionals.size].min
+        end_rest = [a_args.splat_flags.rindex(true) + 1, a_args.positionals.size - @post_positionals.size].max
+        rest_vtxs = a_args.get_rest_args(genv, changes, start_rest, end_rest)
+
+        @req_positionals.each_with_index do |f_vtx, i|
+          if i < start_rest
+            changes.add_edge(genv, a_args.positionals[i], f_vtx)
+          else
+            rest_vtxs.each do |vtx|
+              changes.add_edge(genv, vtx, f_vtx)
+            end
+          end
+        end
+        @opt_positionals.each_with_index do |f_vtx, i|
+          i += @req_positionals.size
+          if i < start_rest
+            changes.add_edge(genv, a_args.positionals[i], f_vtx)
+          else
+            rest_vtxs.each do |vtx|
+              changes.add_edge(genv, vtx, f_vtx)
+            end
+          end
+        end
+        @post_positionals.each_with_index do |f_vtx, i|
+          i += a_args.positionals.size - @post_positionals.size
+          if end_rest <= i
+            changes.add_edge(genv, a_args.positionals[i], f_vtx)
+          else
+            rest_vtxs.each do |vtx|
+              changes.add_edge(genv, vtx, f_vtx)
+            end
+          end
+        end
+
+        if @rest_positionals
+          rest_vtxs.each do |vtx|
+            @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
+        # there is no splat actual argument
+
+        lower = @req_positionals.size + @post_positionals.size
+        upper = @rest_positionals ? nil : lower + @opt_positionals.size
+        if a_args.positionals.size < lower || (upper && upper < a_args.positionals.size)
+          meth = changes.node.mid_code_range ? :mid_code_range : :code_range
+          err = "#{ a_args.positionals.size } for #{ lower }#{ upper ? lower < upper ? "...#{ upper }" : "" : "+" }"
+          changes.add_diagnostic(meth, "wrong number of arguments (#{ err })")
+          return false
+        end
+
+        @req_positionals.each_with_index do |f_vtx, i|
+          changes.add_edge(genv, a_args.positionals[i], f_vtx)
+        end
+        @post_positionals.each_with_index do |f_vtx, i|
+          i -= @post_positionals.size
+          changes.add_edge(genv, a_args.positionals[i], f_vtx)
+        end
+        start_rest = @req_positionals.size
+        end_rest = a_args.positionals.size - @post_positionals.size
+        i = 0
+        while i < @opt_positionals.size && start_rest < end_rest
+          f_arg = @opt_positionals[i]
+          changes.add_edge(genv, a_args.positionals[start_rest], f_arg)
+          i += 1
+          start_rest += 1
+        end
+
+        if start_rest < end_rest
+          if @rest_positionals
+            (start_rest..end_rest-1).each do |i|
+              @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
+      end
+
+      if a_args.keywords
+        # TODO: support diagnostics
+        node.req_keywords.zip(@req_keywords) do |name, f_vtx|
+          changes.add_edge(genv, a_args.get_keyword_arg(genv, changes, name), f_vtx)
+        end
+
+        node.opt_keywords.zip(@opt_keywords).each do |name, f_vtx|
+          changes.add_edge(genv, a_args.get_keyword_arg(genv, changes, name), f_vtx)
+        end
+
+        if node.rest_keywords
+          named_keys = node.req_keywords + node.opt_keywords
+          a_args.keywords.each_type do |kw_ty|
+            case kw_ty
+            when Type::Record
+              rest_fields = kw_ty.fields.reject {|key, _| named_keys.include?(key) }
+              base = kw_ty.base_type(genv)
+              rest_record = Type::Record.new(genv, rest_fields, base)
+              changes.add_edge(genv, Source.new(rest_record), @rest_keywords)
+            when Type::Hash, Type::Instance
+              changes.add_edge(genv, Source.new(kw_ty), @rest_keywords)
+            end
+          end
+        end
+      end
+
+      return true
+    end
+
   end
 
   class ActualArguments
@@ -52,6 +182,15 @@ module TypeProf::Core
       )
     end
 
+    # Keywords passed to formals that take none are the last positional hash.
+    def with_keywords_normalized_for(node)
+      return self unless keywords
+      return self if node.no_keywords || node.rest_keywords
+      return self unless node.req_keywords.empty? && node.opt_keywords.empty?
+
+      with_keywords_as_last_positional_hash
+    end
+
     def prepend_positionals(positionals, splat_flags)
       return self if positionals.empty?
 
@@ -245,7 +384,7 @@ module TypeProf::Core
   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
@@ -255,33 +394,68 @@ module TypeProf::Core
       @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 to it.
+    # The parameters before `...` (`def foo(a, b = 1, ...)`) are not forwarded,
+    # and none can follow it.
+    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))
+      if @rest_positionals
+        positionals << Source.new(genv.gen_ary_type(@rest_positionals))
         splat_flags << true
         positionals_omittable << true
       end
 
-      if @rest_positionals
+      # `...` 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
 
-      @post_positionals.each do |arg|
-        positionals << arg
+      @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
 
-      keywords, keywords_omittable = build_keyword_args(genv, changes, node)
-      ForwardingActualArguments.new(positionals, splat_flags, keywords, @block, positionals_omittable, keywords_omittable, true, @activation, activation_required)
+      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)
@@ -386,18 +560,16 @@ module TypeProf::Core
 
     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
@@ -410,13 +582,13 @@ module TypeProf::Core
       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
@@ -424,18 +596,34 @@ module TypeProf::Core
   end
 
   class Block
-    #: (AST::CallBaseNode, Vertex, Array[Vertex], Array[EscapeBox]) -> void
-    def initialize(node, f_ary_arg, f_args, next_boxes)
+    #: (AST::BlockNode, Vertex, Array[Vertex], Array[EscapeBox], FormalArguments?) -> void
+    def initialize(node, f_ary_arg, f_args, next_boxes, formals = nil)
       @node = node
       @f_ary_arg = f_ary_arg
       @f_args = f_args
       @next_boxes = next_boxes
+      # Set when the body is entered like a method rather than yielded to, which
+      # is to say for a lambda: the full formals then bind the call's arguments.
+      @formals = formals
     end
 
     attr_reader :node, :f_args, :next_boxes
 
+    # The arguments of a call that enters this body directly, as Proc#call does.
+    def pass_arguments(genv, changes, a_args)
+      if @formals
+        a_args = a_args.with_keywords_normalized_for(@node)
+        @formals.pass_arguments(changes, genv, a_args, @node)
+        changes.add_edge(genv, a_args.block, @formals.block) if @formals.block && a_args.block
+      else
+        accept_args(genv, changes, a_args.positionals)
+      end
+    end
+
     def accept_args(genv, changes, caller_positionals)
-      if caller_positionals.size == 1 && @f_args.size >= 2
+      if caller_positionals.size == 1 && @f_args.size >= 2 && !@formals
+        # A block deconstructs a sole array argument over its parameters; a
+        # lambda takes it as the one argument it is.
         changes.add_edge(genv, caller_positionals[0], @f_ary_arg)
       else
         caller_positionals.zip(@f_args) do |a_arg, f_arg|
@@ -452,6 +640,10 @@ module TypeProf::Core
   end
 
   class RecordBlock
+    def pass_arguments(genv, changes, a_args)
+      accept_args(genv, changes, a_args.positionals)
+    end
+
     def initialize(node)
       @node = node
       @used = false