steep 1.4.0.dev.2 → 1.4.0.dev.3

data/sig/steep/type_construction.rbs

@@ -20,6 +20,8 @@ module Steep
 
     include NodeHelper
 
+    include ModuleHelper
+
     attr_reader checker: Subtyping::Check
 
     attr_reader source: Source
@@ -30,9 +32,7 @@ module Steep
 
     attr_reader context: TypeInference::Context
 
-    %a{pure} def module_context: () -> TypeInference::Context::ModuleContext?
-
-    def module_context!: () -> TypeInference::Context::ModuleContext
+    %a{pure} def module_context: () -> TypeInference::Context::ModuleContext
 
     %a{pure} def method_context: () -> TypeInference::Context::MethodContext?
 
@@ -40,6 +40,8 @@ module Steep
 
     %a{pure} def block_context: () -> TypeInference::Context::BlockContext?
 
+    def block_context!: () -> TypeInference::Context::BlockContext
+
     %a{pure} def break_context: () -> TypeInference::Context::BreakContext?
 
     %a{pure} def self_type: () -> AST::Types::t
@@ -58,7 +60,7 @@ module Steep
 
     def update_type_env: () { (TypeInference::TypeEnv) -> TypeInference::TypeEnv } -> TypeConstruction
 
-    def check_relation: (sub_type: AST::Types::t, super_type: AST::Types::t, ?constraints: Subtyping::Constraints) -> Subtyping::Result::Base
+    def check_relation: (sub_type: AST::Types::t, super_type: AST::Types::t, ?constraints: Subtyping::Constraints) -> Subtyping::Result::t
 
     # This is a variation of `#check_relation` method.
     # It checks if given subtyping relation `sub_type <: super_type` holds or not, and returns truthy when *doesn't* hold.
@@ -82,7 +84,7 @@ module Steep
 
     def implement_module: (module_name: RBS::TypeName, annotations: AST::Annotation::Collection, ?super_name: RBS::TypeName?) -> AST::Annotation::Implements::Module?
 
-    def default_module_context: (untyped implement_module_name, nesting: untyped) -> untyped
+    def default_module_context: (AST::Annotation::Implements::Module? implement_module_name, nesting: RBS::Resolver::context) -> TypeInference::Context::ModuleContext
 
     def for_module: (untyped node, untyped new_module_name) -> untyped
 
@@ -104,7 +106,7 @@ module Steep
 
     def for_sclass: (Parser::AST::Node node, AST::Types::t `type`) -> TypeConstruction?
 
-    def for_branch: (Parser::AST::Node node, ?break_context: TypeInference::Context::BreakContext?) -> untyped
+    def for_branch: (Parser::AST::Node node, ?break_context: TypeInference::Context::BreakContext?) -> TypeConstruction
 
     def add_typing: (Parser::AST::Node node, type: AST::Types::t, ?constr: TypeConstruction) -> Pair
 
@@ -112,7 +114,7 @@ module Steep
 
     def synthesize: (Parser::AST::Node node, ?hint: AST::Types::t?, ?condition: bool) -> Pair
 
-    def check: (Parser::AST::Node node, AST::Types::t `type`, ?constraints: Subtyping::Constraints) { (AST::Types::t, AST::Types::t, Subtyping::Result::Base) -> void } -> Pair
+    def check: (Parser::AST::Node node, AST::Types::t `type`, ?constraints: Subtyping::Constraints) { (AST::Types::t, AST::Types::t, Subtyping::Result::t) -> void } -> Pair
 
     def masgn_lhs?: (untyped lhs) -> untyped
 
@@ -126,13 +128,43 @@ module Steep
 
     def constant_typename: (Parser::AST::Node parent, Symbol name) -> RBS::TypeName?
 
-    def synthesize_constant: (Parser::AST::Node node, Parser::AST::Node? parent_node, Symbol constant_name) { () -> void } -> [AST::Types::t, TypeConstruction, RBS::TypeName?]
+    # Synthesize a constant declaration -- :cdecl, :class, or :module
+    #
+    # * `node` is the node that references a constant
+    # * `parent_node` is the parent (namespace) of a constant reference
+    # * `constant_name` is the name of constant
+    #
+    # Yields a block that is expected to add an error, or it reports Diagnostic::Ruby::UnknownConstant if not given.
+    #
+    # Returns a tuple of
+    #
+    # * The type of the constant
+    # * TypeConstruction instance after the evaluation
+    # * The full name of the constant
+    #
+    def synthesize_constant_decl: (Parser::AST::Node? node, Parser::AST::Node? parent_node, Symbol constant_name) ?{ () -> void } -> [AST::Types::t, TypeConstruction, RBS::TypeName?]
+
+    # Synthesize a constant reference
+    #
+    # * `node` is the node that references a constant
+    # * `parent_node` is the parent (namespace) of a constant reference
+    # * `constant_name` is the name of constant
+    #
+    # Yields a block that is expected to add an error, or it reports Diagnostic::Ruby::UnknownConstant if not given.
+    #
+    # Returns a tuple of
+    #
+    # * The type of the constant
+    # * TypeConstruction instance after the evaluation
+    # * The full name of the constant
+    #
+    def synthesize_constant: (Parser::AST::Node? node, Parser::AST::Node? parent_node, Symbol constant_name) ?{ () -> void } -> [AST::Types::t, TypeConstruction, RBS::TypeName?]
 
     def optional_proc?: (untyped `type`) -> (untyped | nil | nil | nil | nil)
 
-    def type_lambda: (Parser::AST::Node node, params_node: Parser::AST::Node, body_node: Parser::AST::Node, type_hint: AST::Types::t?) -> Pair
+    def type_lambda: (Parser::AST::Node & Parser::AST::_BlockNode node, params_node: Parser::AST::Node, body_node: Parser::AST::Node, type_hint: AST::Types::t?) -> Pair
 
-    def synthesize_children: (Parser::AST::Node node, ?skips: Array[Parser::AST::Node]) -> TypeConstruction
+    def synthesize_children: (Parser::AST::Node node, ?skips: Array[Parser::AST::Node?]) -> TypeConstruction
 
     # Synthesize `:send`, `:csend`, `:block`, and `:numblock` node
     #
@@ -255,7 +287,13 @@ module Steep
 
     def eliminate_vars: (untyped `type`, untyped variables, ?to: untyped) -> untyped
 
+    # Type check arguments
+    #
+    # * Receives the `method_name` of a method that is being called
+    # * `method_name` is `nil` if it type checks arguments of block or proc
+    #
     def type_check_args: (
+      Symbol | nil,
       TypeInference::SendArgs,
       Subtyping::Constraints,
       Array[Diagnostic::Ruby::Base]
@@ -263,7 +301,7 @@ module Steep
 
     def type_check_argument: (Parser::AST::Node node, type: AST::Types::t, constraints: Subtyping::Constraints, errors: Array[Diagnostic::Ruby::Base], ?report_node: Parser::AST::Node) -> Pair
 
-    def type_block_without_hint: (node: Parser::AST::Node, block_annotations: AST::Annotation::Collection, block_params: TypeInference::BlockParams?, block_body: Parser::AST::Node?) ?{ (Diagnostic::Ruby::Base) -> void } -> void
+    def type_block_without_hint: (node: Parser::AST::Node & Parser::AST::_BlockNode, block_annotations: AST::Annotation::Collection, block_params: TypeInference::BlockParams?, block_body: Parser::AST::Node?) ?{ (Diagnostic::Ruby::Base) -> void } -> void
 
     def set_up_block_mlhs_params_env: (
       Parser::AST::Node mlhs_node,
@@ -299,15 +337,19 @@ module Steep
 
     # Synthesize the block body and returns the type of the body
     #
-    # The constructor can be discarded because it cannot change anything outer than block.
+    # The constructor can be safely discarded because it cannot change anything outer than block.
     #
-    def synthesize_block: (node: Parser::AST::Node, block_type_hint: AST::Types::t?, block_body: Parser::AST::Node?) -> AST::Types::t
+    def synthesize_block: (
+      node: Parser::AST::Node & Parser::AST::_BlockNode,
+      block_type_hint: AST::Types::t?,
+      block_body: Parser::AST::Node?
+    ) -> AST::Types::t
 
-    def nesting: () -> RBS::Resolver::context
+    %a{pure} def nesting: () -> RBS::Resolver::context
 
     def absolute_name: (untyped name) -> untyped
 
-    def union_type: (*AST::Types::t types) -> AST::Types::t
+    def union_type: (*AST::Types::t? types) -> AST::Types::t
 
     # Returns union type of given types
     #
@@ -328,27 +370,35 @@ module Steep
     #
     def union_of_tuple_to_tuple_of_union: (AST::Types::Union) -> AST::Types::Tuple?
 
-    def validate_method_definitions: (untyped node, untyped module_name) -> (nil | untyped)
+    def validate_method_definitions: (Parser::AST::Node node, AST::Annotation::Implements::Module module_name) -> void
 
     def fallback_to_any: (Parser::AST::Node node) ?{ () -> Diagnostic::Ruby::Base } -> Pair
 
-    def self_class?: (untyped node) -> untyped
+    # Return `true` if `node` is `self.class`
+    def self_class?: (Parser::AST::Node node) -> bool
 
-    def namespace_module?: (untyped node) -> (false | untyped)
+    # Returns `true` if the given `node` is a `class` or `module` declaration that only contains module/class definitions
+    #
+    def namespace_module?: (Parser::AST::Node node) -> bool
 
     def type_any_rec: (Parser::AST::Node node) -> Pair
 
     def unwrap: (AST::Types::t `type`) -> AST::Types::t
 
+    # Returns `nil` if `type` is recursive
+    #
+    # See `Factory#deep_expand_alias`.
+    #
     def deep_expand_alias: (AST::Types::t `type`) -> AST::Types::t?
 
-    def flatten_union: (AST::Types::t `type`) -> Array[AST::Types::t]
+    # `A | B | ... | Z` => `[A, B, ..., Z]`
+    def flatten_union: (AST::Types::t) -> Array[AST::Types::t]
 
-    def select_flatten_types: (untyped `type`) { () -> untyped } -> untyped
+    def select_flatten_types: (AST::Types::t) { (AST::Types::t) -> boolish } -> Array[AST::Types::t]
 
-    def partition_flatten_types: (AST::Types::t `type`) { (AST::Types::t) -> boolish } -> [Array[AST::Types::t], Array[AST::Types::t]]
+    def partition_flatten_types: (AST::Types::t) { (AST::Types::t) -> boolish } -> [Array[AST::Types::t], Array[AST::Types::t]]
 
-    def flatten_array_elements: (untyped `type`) -> untyped
+    def flatten_array_elements: (AST::Types::t) -> Array[AST::Types::t]
 
     def expand_alias: (AST::Types::t `type`) -> AST::Types::t
                     | [A] (AST::Types::t) { (AST::Types::t) -> A } -> A
@@ -357,7 +407,12 @@ module Steep
 
     def to_instance_type: (untyped `type`, ?args: untyped?) -> untyped
 
-    def try_tuple_type!: (Parser::AST::Node node, ?hint: AST::Types::Tuple?) -> Pair
+    # Synthesize the type of a node, assuming it has tuple type when possible
+    #
+    # * Try `#try_tuple_type` if applicable, or
+    # * Run the normal `#synthesize` else
+    #
+    def try_tuple_type!: (Parser::AST::Node node, ?hint: AST::Types::t?) -> Pair
 
     # Try to give `array_node` a tuple type
     #
@@ -428,22 +483,36 @@ module Steep
     # * When hint is union type, it tries recursively with the union cases.
     # * Otherwise, it tries to be a hash instance.
     #
-    def type_hash: (untyped hash_node, hint: untyped) -> untyped
+    def type_hash: (Parser::AST::Node hash_node, hint: AST::Types::t?) -> untyped
 
     # Returns the first one from elements of `types` that returns a type `t` where `t <: hint`.
     #
     def pick_one_of: (Array[AST::Types::t] types, range: untyped) { (AST::Types::t hint, TypeConstruction) -> Pair? } -> Pair?
 
-    def save_typing: () -> untyped
+    # *Commit* the transaction (current typing) and returns a `TypeConstruction` with saved typing
+    #
+    # ```ruby
+    # transaction = typing.new_child(range) {|child| constr.with_new_typing(child) }
+    #
+    # # Do something that may fail
+    #
+    # if succeeded
+    #   # Commit the may-fail operation
+    #   constr = transaction.save_typing()
+    # else
+    #   # Abort the transaction
+    # end
+    # ```
+    def save_typing: () -> TypeConstruction
 
-    # Returns `true` if a method call can be identified as _pure_.
+    # Returns `true` if a method call can be identified as _pure_:
     #
-    # * The `node` is not a call with call
-    # * It always calls _pure_ method
-    # * The `receiver` is _pure_
+    # * The `node` is not a call with block,
+    # * It always calls _pure_ method,
+    # * The `receiver` is _pure_, and
     # * All of the arguments are _pure_
     #
-    def pure_send?: (TypeInference::MethodCall::Typed call, Parser::AST::Node receiver, Array[Parser::AST::Node] arguments) -> bool
+    def pure_send?: (TypeInference::MethodCall::Typed call, Parser::AST::Node? receiver, Array[Parser::AST::Node] arguments) -> bool
 
     # Transform given `node` to a node that has a local variable instead of the outer most call/non-value node
     #

data/sig/steep/type_inference/block_params.rbs

@@ -149,6 +149,10 @@ module Steep
 
       def each: () { (Param | MultipleParam) -> void } -> void
               | () -> Enumerator[Param | MultipleParam, void]
+
+      # Yields `Param` recursively
+      # 
+      def each_single_param: () { (Param) -> void } -> void
     end
   end
 end

data/sig/steep/type_inference/context.rbs

@@ -1,31 +1,45 @@
+use Steep::Interface::Function::Params, Steep::Interface::Block
+
 module Steep
   module TypeInference
+    # Type checking context
     class Context
+      # Information about the method which the body is being type checked
+      #
       class MethodContext
+        # Name of the method
         attr_reader name: Symbol?
 
+        # `nil` when RBS doesn't have the corresponding method definition
         attr_reader method: RBS::Definition::Method?
 
+        # `nil` when no method type is given
         attr_reader method_type: Interface::MethodType?
 
+        # Falls back to `untyped`
         attr_reader return_type: AST::Types::t
 
-        attr_reader constructor: bool
-
+        # The *super* method if identified
         attr_reader super_method: RBS::Definition::Method?
 
+        # The type of forwarding params when `...` is given
+        attr_reader forward_arg_type: [Params, Block?]?
+
         def initialize: (
           name: Symbol,
           method: RBS::Definition::Method?,
           method_type: Interface::MethodType?,
           return_type: AST::Types::t,
-          constructor: bool,
-          super_method: RBS::Definition::Method?
+          super_method: RBS::Definition::Method?,
+          forward_arg_type: [Params, Block?]?
         ) -> void
 
+        # Type of the block of the current method type
         def block_type: () -> Interface::Block?
       end
 
+      # Information about the block which the body is being type checked
+      #
       class BlockContext
         # The type of block itself
         #
@@ -38,6 +52,7 @@ module Steep
         def subst: (Interface::Substitution) -> BlockContext
       end
 
+      # Context about the `break` syntax
       class BreakContext
         # Type of arguments to `break` statement
         #
@@ -54,23 +69,40 @@ module Steep
         def subst: (Interface::Substitution) -> BreakContext
       end
 
+      # Information about the module which the body is being type checked
+      #
       class ModuleContext
+        # The type of an instance of current module
         attr_reader instance_type: AST::Types::t
 
+        # The type of singleton of current module
         attr_reader module_type: AST::Types::t
 
-        attr_reader defined_instance_methods: untyped
+        # The set of name of instance methods that is defined in the `module`/`class` statement
+        attr_reader defined_instance_methods: Set[Symbol]
 
-        attr_reader defined_module_methods: untyped
+        # The set of name of singleton methods that is defined in the `module`/`class` statement
+        attr_reader defined_module_methods: Set[Symbol]
 
+        # The nesting of current module
+        #
+        # Cannot be `nil`.
+        #
         attr_reader nesting: RBS::Resolver::context
 
-        attr_reader implement_name: untyped
+        # The name that is given to `@implements` annotation
+        #
+        # `nil` when no `@implements` annotation is given.
+        #
+        attr_reader implement_name: AST::Annotation::Implements::Module?
 
+        # The name of the class/module.
         attr_reader class_name: RBS::TypeName
 
+        # The definition of the instance of the module
         attr_reader instance_definition: RBS::Definition?
 
+        # The definition of the singleton of the module
         attr_reader module_definition: RBS::Definition?
 
         @class_variables: Hash[Symbol, RBS::Types::t]?
@@ -78,19 +110,20 @@ module Steep
         def initialize: (
           instance_type: AST::Types::t,
           module_type: AST::Types::t,
-          implement_name: untyped,
+          implement_name: AST::Annotation::Implements::Module?,
           class_name: RBS::TypeName,
           nesting: RBS::Resolver::context,
           ?instance_definition: RBS::Definition?,
           ?module_definition: RBS::Definition?
         ) -> void
 
-        def class_variables: () -> Hash[Symbol, RBS::Types::t]?
+        # Returns a hash from the name of a class variable to its type
+        %a{pure} def class_variables: () -> Hash[Symbol, RBS::Types::t]?
 
         def update: (
           ?instance_type: AST::Types::t,
           ?module_type: AST::Types::t,
-          ?implement_name: untyped,
+          ?implement_name: AST::Annotation::Implements::Module?,
           ?class_name: RBS::TypeName,
           ?instance_definition: RBS::Definition?,
           ?module_definition: RBS::Definition?,
@@ -98,6 +131,8 @@ module Steep
         ) -> ModuleContext
       end
 
+      # Information about the free type variables
+      #
       class TypeVariableContext
         attr_reader table: Hash[Symbol, Interface::TypeParam]
 
@@ -105,6 +140,7 @@ module Steep
 
         def initialize: (Array[Interface::TypeParam] type_params, ?parent_context: TypeVariableContext?) -> void
 
+        # Returns the upper bound of a type variable
         def []: (Symbol name) -> AST::Types::t?
 
         def upper_bounds: () -> Hash[Symbol, AST::Types::t]
@@ -112,9 +148,14 @@ module Steep
         def self.empty: () -> TypeVariableContext
       end
 
-      attr_reader call_context: untyped
+      # The caller where a method is called from
+      attr_reader call_context: MethodCall::context
 
-      attr_reader method_context: untyped
+      # MethodContext for current execution point
+      #
+      # `nil` when not in any method definition.
+      #
+      attr_reader method_context: MethodContext?
 
       # BlockContext for current execution point
       #
@@ -122,10 +163,17 @@ module Steep
       #
       attr_reader block_context: BlockContext?
 
+      # BreakContext for current execution point
+      #
+      # `nil` if `break` is not allowed.
+      #
       attr_reader break_context: BreakContext?
 
-      attr_reader module_context: ModuleContext?
+      # ModuleContext for current execution point
+      attr_reader module_context: ModuleContext
 
+      # The type of `self`
+      #
       attr_reader self_type: AST::Types::t
 
       attr_reader type_env: TypeEnv
@@ -133,25 +181,25 @@ module Steep
       attr_reader variable_context: TypeVariableContext
 
       def initialize: (
-        method_context: untyped,
+        method_context: MethodContext?,
         block_context: BlockContext?,
         break_context: BreakContext?,
-        module_context: ModuleContext?,
-        self_type: untyped,
+        module_context: ModuleContext,
+        self_type: AST::Types::t,
         type_env: TypeEnv,
-        call_context: untyped,
+        call_context: MethodCall::context,
         variable_context: TypeVariableContext
       ) -> void
 
       def with: (
-        ?method_context: untyped,
+        ?method_context: MethodContext?,
         ?block_context: BlockContext?,
         ?break_context: BreakContext?,
-        ?module_context: ModuleContext?,
-        ?self_type: untyped,
+        ?module_context: ModuleContext,
+        ?self_type: AST::Types::t,
         ?type_env: TypeEnv,
-        ?call_context: untyped,
-        ?variable_context: untyped
+        ?call_context: MethodCall::context,
+        ?variable_context: TypeVariableContext
       ) -> Context
 
       def factory: () -> AST::Types::Factory

data/sig/steep/type_inference/method_params.rbs

@@ -1,24 +1,31 @@
+use Parser::AST::Node, Steep::Interface::MethodType
+use Steep::Interface::Function::Params, Steep::Interface::Block
+
 module Steep
   module TypeInference
+    # A MethodParams object provides the information of parameters from MethodType and nodes
+    #
+    # It primarly provides a mapping from a local variable (method parameter) to its type.
+    #
     class MethodParams
       class BaseParameter
         attr_reader name: Symbol
 
-        attr_reader type: untyped
+        attr_reader type: AST::Types::t?
 
-        attr_reader node: Parser::AST::Node
+        attr_reader node: Node
 
-        def initialize: (name: Symbol, type: untyped, node: Parser::AST::Node) -> void
+        def initialize: (name: Symbol, type: AST::Types::t?, node: Node) -> void
 
         def optional?: () -> bool
 
-        def value: () -> Parser::AST::Node
+        def value: () -> Node?
 
         def var_type: () -> AST::Types::t
 
         def untyped?: () -> bool
 
-        def ==: (untyped other) -> untyped
+        def ==: (untyped other) -> bool
 
         alias eql? ==
 
@@ -34,27 +41,25 @@ module Steep
       class BaseRestParameter
         attr_reader name: Symbol
 
-        attr_reader type: untyped
+        attr_reader type: AST::Types::t?
 
-        attr_reader node: Parser::AST::Node
+        attr_reader node: Node
 
-        def initialize: (name: Symbol, type: untyped, node: Parser::AST::Node) -> void
+        def initialize: (name: Symbol, type: AST::Types::t?, node: Node) -> void
 
         def ==: (untyped other) -> bool
 
         alias eql? ==
 
         def hash: () -> Integer
-
-        def var_type: () -> AST::Types::t
       end
 
       class PositionalRestParameter < BaseRestParameter
-        def var_type: () -> AST::Types::t
+        def var_type: () -> AST::Types::Name::Instance
       end
 
       class KeywordRestParameter < BaseRestParameter
-        def var_type: () -> AST::Types::t
+        def var_type: () -> AST::Types::Name::Instance
       end
 
       class BlockParameter
@@ -62,11 +67,11 @@ module Steep
 
         attr_reader type: Interface::Function?
 
-        attr_reader node: Parser::AST::Node
+        attr_reader node: Node
 
         attr_reader self_type: AST::Types::t?
 
-        def initialize: (name: Symbol, type: Interface::Function?, node: Parser::AST::Node, optional: boolish, self_type: AST::Types::t?) -> void
+        def initialize: (name: Symbol, type: Interface::Function?, node: Node, optional: boolish, self_type: AST::Types::t?) -> void
 
         @optional: boolish
 
@@ -81,28 +86,42 @@ module Steep
         def hash: () -> Integer
       end
 
-      attr_reader args: untyped
+      type param = PositionalParameter | KeywordParameter | PositionalRestParameter | KeywordRestParameter | BlockParameter
+
+      # The children of `:args` node
+      attr_reader args: Array[Node]
+
+      attr_reader method_type: MethodType?
 
-      attr_reader method_type: untyped
+      # Mapping from the name of parameter to parameter object
+      attr_reader params: Hash[Symbol, param]
 
-      attr_reader params: untyped
+      attr_reader errors: Array[Diagnostic::Ruby::Base]
 
-      attr_reader errors: untyped
+      # The type of `...`
+      #
+      # `nil` if the node doesn't have it.
+      #
+      attr_reader forward_arg_type: [Params, Block?]?
 
-      def initialize: (args: untyped, method_type: untyped) -> void
+      def initialize: (args: Array[Node], method_type: MethodType?, forward_arg_type: [Params, Block?]?) -> void
 
-      def []: (untyped name) -> untyped
+      def []: (Symbol name) -> param
+
+      def param?: (Symbol) -> bool
 
       def size: () -> Integer
 
-      def each_param: () { (BaseParameter | BaseRestParameter | BlockParameter) -> void } -> void
-                    | () -> Enumerator[BaseParameter | BaseRestParameter | BlockParameter, void]
+      def each_param: () { (param) -> void } -> void
+                    | () -> Enumerator[param, void]
 
       def each: () { (Symbol, AST::Types::t) -> void } -> void
 
-      def self.empty: (node: Parser::AST::Node) -> MethodParams
+      def update: (?forward_arg_type: [Params, Block?]?) -> MethodParams
+
+      def self.empty: (node: Node) -> MethodParams
 
-      def self.build: (node: Parser::AST::Node, method_type: untyped) -> MethodParams
+      def self.build: (node: Node, method_type: MethodType) -> MethodParams
     end
   end
 end

data/sig/steep/type_inference/multiple_assignment.rbs

@@ -59,7 +59,7 @@ module Steep
       # Returns a type hint for multiple assignment right hand side
       #
       # It constructs a structure of tuple types, based on the assignment lhs, and variable types.
-      # 
+      #
       def hint_for_mlhs: (Parser::AST::Node mlhs, TypeEnv env) -> AST::Types::t?
 
       private

data/sig/steep/type_inference/send_args.rbs

@@ -68,7 +68,7 @@ module Steep
 
         def following_args: () -> Array[Parser::AST::Node]
 
-        def param: () -> Interface::Function::Params::PositionalParams::param?
+        %a{pure} def param: () -> Interface::Function::Params::PositionalParams::param?
 
         def update: (?index: Integer, ?positional_params: Interface::Function::Params::PositionalParams?, ?uniform: bool) -> PositionalArgs
 
@@ -198,6 +198,14 @@ module Steep
         def node_type: () -> AST::Types::t
       end
 
+      class ForwardedArgs
+        attr_reader node: Parser::AST::Node
+
+        attr_reader params: Interface::Function::Params
+
+        def initialize: (node: Parser::AST::Node, params: Interface::Function::Params) -> void
+      end
+
       attr_reader node: Parser::AST::Node
 
       attr_reader arguments: Array[Parser::AST::Node]
@@ -216,14 +224,16 @@ module Steep
 
       def kwargs_node: () -> Parser::AST::Node?
 
+      def forwarded_args_node: () -> Parser::AST::Node?
+
       def positional_arg: () -> PositionalArgs
 
       def keyword_args: () -> KeywordArgs
 
       def block_pass_arg: () -> BlockPassArg
 
-      def each: () { (PositionalArgs::arg | KeywordArgs::arg) -> void } -> Array[Diagnostic::Ruby::Base]
-              | () -> Enumerator[PositionalArgs::arg | KeywordArgs::arg, Array[Diagnostic::Ruby::Base]]
+      def each: () { (PositionalArgs::arg | KeywordArgs::arg) -> void } -> [ForwardedArgs?, Array[Diagnostic::Ruby::Base]]
+              | () -> Enumerator[PositionalArgs::arg | KeywordArgs::arg, [ForwardedArgs?, Array[Diagnostic::Ruby::Base]]]
     end
   end
 end