steep 1.1.1 → 1.2.0.pre.1

data/sig/steep/subtyping/relation.rbs

@@ -1,51 +1,53 @@
 module Steep
   module Subtyping
-    class Relation
-      attr_reader sub_type: untyped
+    class Relation[out Subject < Object]
+      attr_reader sub_type: Subject
 
-      attr_reader super_type: untyped
+      attr_reader super_type: Subject
 
-      def initialize: (sub_type: untyped, super_type: untyped) -> void
+      def initialize: (sub_type: Subject, super_type: Subject) -> void
 
-      def hash: () -> untyped
+      def hash: () -> Integer
 
-      def ==: (untyped other) -> untyped
+      def ==: (untyped other) -> bool
 
       alias eql? ==
 
       def to_s: () -> ::String
 
-      def to_ary: () -> ::Array[untyped]
+      def to_ary: () -> [Subject, Subject]
 
-      def type?: () -> untyped
+      def type?: () -> bool
 
-      def interface?: () -> untyped
+      def interface?: () -> bool
 
-      def method?: () -> untyped
+      def method?: () -> bool
 
-      def function?: () -> untyped
+      def function?: () -> bool
 
-      def params?: () -> untyped
+      def params?: () -> bool
 
-      def block?: () -> untyped
+      def block?: () -> bool
 
-      def assert_type: (untyped `type`) -> (untyped | nil)
+      type relation_type = :type | :interface | :method | :function | :params | :block
 
-      def type!: () -> untyped
+      def assert_type: (relation_type `type`) -> void
 
-      def interface!: () -> untyped
+      def type!: () -> void
 
-      def method!: () -> untyped
+      def interface!: () -> void
 
-      def function!: () -> untyped
+      def method!: () -> void
 
-      def params!: () -> untyped
+      def function!: () -> void
 
-      def block!: () -> untyped
+      def params!: () -> void
 
-      def map: () { (untyped) -> untyped } -> untyped
+      def block!: () -> void
 
-      def flip: () -> untyped
+      def map: [T < Object] () { (Subject) -> T } -> Relation[T]
+
+      def flip: () -> Relation[Subject]
     end
   end
 end

data/sig/steep/subtyping/result.rbs

@@ -4,19 +4,19 @@ module Steep
       type t = Skip | Expand | All | Any | Success | Failure
 
       class Base
-        attr_reader relation: Relation
+        attr_reader relation: Relation[untyped]
 
-        def initialize: (Relation relation) -> void
+        def initialize: (Relation[untyped] relation) -> void
 
         def failure?: () -> bool
 
         def success?: () -> bool
 
-        def then: [A] () { (self) -> A } -> A
+        def then: () { (self) -> void } -> self
 
-        def else: [A] () { (self) -> A } -> A
+        def else: () { (self) -> void } -> self
 
-        def failure_path: (?untyped path) -> untyped
+        def failure_path: (?Array[t] path) -> Array[t]?
       end
 
       class Skip < Base
@@ -28,50 +28,61 @@ module Steep
       end
 
       class Expand < Base
-        attr_reader child: untyped
+        attr_reader child: t
 
-        def initialize: (untyped relation) { (untyped) -> untyped } -> void
+        def initialize: (Relation[untyped] relation) { (Relation[untyped]) -> t } -> void
 
-        def success?: () -> untyped
+        def success?: () -> bool
 
-        def failure_path: (?untyped path) -> (untyped | nil)
+        def failure_path: (?Array[t] path) -> Array[t]?
       end
 
       class All < Base
-        attr_reader branches: untyped
+        attr_reader branches: Array[t]
 
-        def initialize: (untyped relation) -> void
+        def initialize: (Relation[untyped] relation) -> void
+
+        @failure: bool
 
         # Returns `false` if no future `#add` changes the result.
-        def add: (*untyped relations) { (untyped) -> untyped } -> untyped
+        def add: [T < Object] (*Relation[T] relations) { (Relation[T]) -> t? } -> bool
 
-        def success?: () -> untyped
+        # Returns `false` if no future `#add` changes the result.
+        def add_result: (t?) -> bool
 
-        def failure?: () -> untyped
+        def success?: () -> bool
+
+        def failure?: () -> bool
 
-        def failure_path: (?untyped path) -> (untyped | nil)
+        def failure_path: (?Array[t] path) -> Array[t]?
       end
 
       class Any < Base
-        attr_reader branches: untyped
+        attr_reader branches: Array[t]
 
-        def initialize: (untyped relation) -> void
+        def initialize: (Relation[untyped] relation) -> void
+
+        @success: bool
 
         # Returns `false` if no future `#add` changes the result.
-        def add: (*untyped relations) { (untyped) -> untyped } -> untyped
+        def add: [T < Object] (*Relation[T] relations) { (Relation[T]) -> t } -> bool
 
-        def success?: () -> untyped
+        def success?: () -> bool
 
-        def failure_path: (?untyped path) -> (untyped | nil)
+        def failure_path: (?Array[t] path) -> Array[t]?
       end
 
       class Success < Base
         def success?: () -> true
 
-        def failure_path: (?untyped path) -> nil
+        def failure_path: (?Array[t] path) -> Array[t]?
       end
 
       class Failure < Base
+        type error = MethodMissingError | BlockMismatchError | ParameterMismatchError
+                   | UnknownPairError | PolyMethodSubtyping | UnsatisfiedConstraints
+                   | SelfBindingMismatch
+
         class MethodMissingError
           attr_reader name: untyped
 
@@ -128,29 +139,36 @@ module Steep
           def message: () -> ::String
         end
 
-        attr_reader error: untyped
+        class SelfBindingMismatch
+          def initialize: () -> void
 
-        def initialize: (untyped relation, untyped error) -> void
+          def message: () -> String
+        end
+
+        attr_reader error: error
+
+        def initialize: (Relation[untyped] relation, error error) -> void
 
         def success?: () -> false
 
-        def failure_path: (?untyped path) -> untyped
+        def failure_path: (?Array[t] path) -> Array[t]?
       end
 
       module Helper
-        def Skip: (untyped relation) -> untyped
+        def Skip: (Relation[untyped] relation) -> Skip
 
-        def Expand: (untyped relation) { () -> untyped } -> untyped
+        def Expand: [T < Object] (Relation[T] relation) { (Relation[T]) -> t } -> Expand
 
-        def All: (untyped relation) { () -> untyped } -> untyped
+        def All: (Relation[untyped] relation) { (All) -> void } -> All
 
-        def Any: (untyped relation) { () -> untyped } -> untyped
+        def Any: (Relation[untyped] relation) { (Any) -> void } -> Any
 
-        def Success: (untyped relation) -> untyped
+        def Success: (Relation[untyped] relation) -> Success
 
         alias success Success
 
-        def Failure: (untyped relation, ?untyped? error) { () -> untyped } -> untyped
+        def Failure: (Relation[untyped] relation, Failure::error) -> Failure
+                   | (Relation[untyped]) { () -> Failure::error } -> Failure
       end
     end
   end

data/sig/steep/subtyping/variable_variance.rbs

@@ -13,6 +13,8 @@ module Steep
 
       def invariant?: (untyped var) -> untyped
 
+      def self.from_type: (AST::Types::t) -> VariableVariance
+
       def self.from_method_type: (untyped method_type) -> untyped
 
       def self.add_params: (untyped params, block: untyped, covariants: untyped, contravariants: untyped) -> untyped

data/sig/steep/type_construction.rbs

@@ -30,17 +30,17 @@ module Steep
 
     attr_reader context: TypeInference::Context
 
-    def module_context: () -> TypeInference::Context::ModuleContext?
+    %a{pure} def module_context: () -> TypeInference::Context::ModuleContext?
 
-    def method_context: () -> TypeInference::Context::MethodContext?
+    %a{pure} def method_context: () -> TypeInference::Context::MethodContext?
 
-    def block_context: () -> TypeInference::Context::BlockContext?
+    %a{pure} def block_context: () -> TypeInference::Context::BlockContext?
 
-    def break_context: () -> TypeInference::Context::BreakContext?
+    %a{pure} def break_context: () -> TypeInference::Context::BreakContext?
 
-    def self_type: () -> untyped
+    %a{pure} def self_type: () -> AST::Types::t
 
-    def variable_context: () -> TypeInference::Context::TypeVariableContext
+    %a{pure} def variable_context: () -> TypeInference::Context::TypeVariableContext
 
     def initialize: (checker: untyped, source: untyped, annotations: untyped, typing: untyped, context: untyped) -> void
 
@@ -90,6 +90,14 @@ module Steep
 
     def with_sclass_constr: [A] (Parser::AST::Node node, AST::Types::t `type`) { (TypeConstruction?) -> A } -> A
 
+    # Returns one-level _meta_ type from given type
+    #
+    # * Returns singleton type of the type name if instance type is given
+    # * Returns `::Class` if singleton type is given
+    # * Returns `nil` otherwise
+    #
+    def meta_type: (AST::Types::t) -> AST::Types::t?
+
     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
@@ -122,11 +130,19 @@ module Steep
 
     def synthesize_children: (Parser::AST::Node node, ?skips: Array[Parser::AST::Node]) -> TypeConstruction
 
-    def type_send_interface: (Parser::AST::Node node, interface: Interface::Interface, receiver: Parser::AST::Node, receiver_type: AST::Types::t, method_name: Symbol, arguments: Array[Parser::AST::Node], block_params: Parser::AST::Node?, block_body: Parser::AST::Node?) -> Pair
+    def type_send_interface: (Parser::AST::Node node, interface: Interface::Shape, receiver: Parser::AST::Node, receiver_type: AST::Types::t, method_name: Symbol, arguments: Array[Parser::AST::Node], block_params: Parser::AST::Node?, block_body: Parser::AST::Node?) -> Pair
 
     def type_send: (untyped node, send_node: untyped, block_params: untyped, block_body: untyped, ?unwrap: bool) -> untyped
 
-    def calculate_interface: (untyped `type`, private: untyped, ?self_type: untyped) -> untyped
+    def builder_config: () -> Interface::Builder::Config
+
+    # Calculates the shape (interface) of an type
+    #
+    # * Returns `nil` if the type cannot be translated to a shape
+    # * Returns Shape::Entry instead of Shape, if `method_name` is given
+    #
+    def calculate_interface: (AST::Types::t `type`, private: bool) -> Interface::Shape?
+                           | (AST::Types::t `type`, Symbol method_name, private: bool) -> Interface::Shape::Entry?
 
     def expand_self: (untyped `type`) -> untyped
 
@@ -140,7 +156,7 @@ module Steep
       Parser::AST::Node node,
       method_name: Symbol,
       receiver_type: AST::Types::t,
-      method: Interface::Interface::Entry,
+      method: Interface::Shape::Entry,
       arguments: Array[Parser::AST::Node],
       block_params: Parser::AST::Node?,
       block_body: Parser::AST::Node?,
@@ -149,7 +165,8 @@ module Steep
 
     def inspect: () -> ::String
 
-    def with_child_typing: (range: untyped) { (untyped) -> untyped } -> untyped
+    def with_child_typing: [A] (range: Range[Integer]) { (TypeConstruction) -> A } -> A
+                         | (range: Range[Integer]) -> TypeConstruction
 
     # Bypass :splat and :kwsplat
     def bypass_splat: (untyped node) { (untyped) -> untyped } -> untyped
@@ -169,25 +186,57 @@ module Steep
 
     def eliminate_vars: (untyped `type`, untyped variables, ?to: untyped) -> untyped
 
-    def try_method_type: (Parser::AST::Node node, receiver_type: AST::Types::t, method_name: Symbol, method_type: Interface::MethodType, arguments: Array[Parser::AST::Node], block_params: Parser::AST::Node?, block_body: Parser::AST::Node?, topdown_hint: untyped) -> [TypeInference::MethodCall::t, TypeConstruction]
+    def try_method_type: (
+      Parser::AST::Node node,
+      receiver_type: AST::Types::t,
+      method_name: Symbol,
+      method_type: Interface::MethodType,
+      arguments: Array[Parser::AST::Node],
+      block_params: Parser::AST::Node?,
+      block_body: Parser::AST::Node?,
+      topdown_hint: untyped
+    ) -> [TypeInference::MethodCall::t, TypeConstruction]
+
+    def type_check_args: (
+      TypeInference::SendArgs,
+      Subtyping::Constraints,
+      Array[Diagnostic::Ruby::Base]
+    ) -> TypeConstruction
+
+    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_check_argument: (Parser::AST::Node node, receiver_type: AST::Types::t, 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: untyped, block_annotations: untyped, block_params: untyped, block_body: untyped) { () -> untyped } -> untyped
+    def set_up_block_mlhs_params_env: (
+      Parser::AST::Node mlhs_node,
+      AST::Types::t type,
+      Hash[Symbol, AST::Types::t]
+    ) { (Parser::AST::Node error_mlhs_node, AST::Types::t type) -> void } -> void
 
     # Returns a Pair of
     #
     # * TypeConstruction to type check the block, and
     # * Set of local variable names to unpin after type checking the block
     #
+    # ### Arguments
+    #
+    # * `body_node` Block body node
+    # * `block_params` BlockParams object
+    # * `block_param_hint` Type hint of the block parameters
+    # * `block_type_hint` Type hint of the block body
+    # * `block_block_hint` Type hint of the block that will be given to the block
+    # * `block_annotations` Annotations given to the block body
+    # * `node_type_hint` Type hint of block call node
+    #
     def for_block: (
         Parser::AST::Node? body_node,
         block_params: TypeInference::BlockParams,
-        block_param_hint: TypeInference::MethodParams?,
+        block_param_hint: Interface::Function::Params?,
         block_type_hint: AST::Types::t?,
         block_block_hint: Interface::Block?,
         block_annotations: AST::Annotation::Collection,
-        node_type_hint: AST::Types::t?
+        node_type_hint: AST::Types::t?,
+        block_self_hint: AST::Types::t?
       ) -> TypeConstruction
 
     # Synthesize the block body and returns the type of the body
@@ -202,6 +251,25 @@ module Steep
 
     def union_type: (*AST::Types::t types) -> AST::Types::t
 
+    # Returns union type of given types
+    #
+    # If one of the types is a subtype of another type, the _subtype_ will be ignored.
+    #
+    # ```ruby
+    # union_type(`String`, `Object`)   # => `Object`
+    # union_type(`String`, `Integer`)   # => `String | Integer`
+    # ```
+    #
+    def union_type_unify: (*AST::Types::t types) -> AST::Types::t
+
+    # Translate a union of tuple types to a tuple of union types
+    #
+    # * ([A, B] | [C, D, E]) => [A | C, B | D, E?]
+    #
+    # Returns `nil` if the translation cannot apply.
+    #
+    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 fallback_to_any: (Parser::AST::Node node) ?{ () -> Diagnostic::Ruby::Base } -> Pair
@@ -212,12 +280,11 @@ module Steep
 
     def type_any_rec: (Parser::AST::Node node) -> Pair
 
-    def unwrap: (untyped `type`) -> untyped
+    def unwrap: (AST::Types::t `type`) -> AST::Types::t
 
-    def deep_expand_alias: (AST::Types::t `type`) -> AST::Types::t
-                         | [A] (AST::Types::t) { (AST::Types::t) -> A } -> A
+    def deep_expand_alias: (AST::Types::t `type`) -> AST::Types::t?
 
-    def flatten_union: (untyped `type`) -> untyped
+    def flatten_union: (AST::Types::t `type`) -> Array[AST::Types::t]
 
     def select_flatten_types: (untyped `type`) { () -> untyped } -> untyped
 
@@ -232,11 +299,28 @@ module Steep
 
     def to_instance_type: (untyped `type`, ?args: untyped?) -> untyped
 
-    def try_tuple_type!: (Parser::AST::Node node, ?hint: AST::Types::t?) -> Pair
+    def try_tuple_type!: (Parser::AST::Node node, ?hint: AST::Types::Tuple?) -> Pair
 
-    def try_tuple_type: (Parser::AST::Node node, AST::Types::Tuple? hint) -> (nil | untyped)
+    # Try to give `array_node` a tuple type
+    #
+    # * If `hint` is given, the array element would receive a hint of element of `hint` type.
+    # * If `hint` it not given, `array_node` is assumed to have a tuple type, but no assumption on element types.
+    #
+    # Returns `nil` when `array_node` includes `*` (splat) node.
+    #
+    # ```ruby
+    # try_tuple_type(`[1, 2]`, nil)               # => `[Integer, Integer, Integer]`
+    # try_tuple_type(`[1]`, `[Integer, Integer]`) # => `[Integer]`
+    # try_tuple_type(`[1, 2]`, `[Integer]`)       # => `[Integer, Integer]`
+    # try_tuple_type(`[1, *]`, `[Integer]`)       # => nil
+    # ```
+    #
+    # Note that `typing` will be updated even when it returns `nil`.
+    # You probably should try `with_new_typing` to make the result _atomic_.
+    #
+    def try_tuple_type: (Parser::AST::Node array_node, AST::Types::Tuple? hint) -> Pair?
 
-    # Try to convert a object of `type` with zero-arity method `method`.
+    # Try to convert an object of `type` with zero-arity method `method`.
     #
     # Returns `nil` when
     #
@@ -250,7 +334,26 @@ module Steep
     #
     def try_convert: (AST::Types::t `type`, Symbol method) -> AST::Types::t?
 
-    def try_array_type: (untyped node, untyped hint) -> untyped
+    # Try to convert an object of `type` to an Array-ish
+    #
+    # * `untyped` is arrayish
+    #
+    def try_convert_to_array: (AST::Types::t) -> AST::Types::t?
+
+    # Returns a type if given type is arrayish
+    #
+    # * Aliases will be unfolded to arrayish type
+    # * Returns `nil` if given type is not arrayish
+    # * `untyped` is arrayish if `untyped_is:` is `true` (defaults to `false`)
+    #
+    def arrayish_type?: (AST::Types::t, ?untyped_is: bool) -> AST::Types::t?
+
+    # Returns the type is given type is a subtype of Array
+    def semantically_arrayish_type?: (AST::Types::t) -> AST::Types::t?
+
+    # Give an array node a type with hint
+    #
+    def try_array_type: (Parser::AST::Node node, AST::Types::Name::Instance? hint) -> Pair
 
     # Returns a record type if `hash_node` can have a record type.
     #
@@ -296,5 +399,11 @@ module Steep
     # This is typically used for transforming assginment node for case condition.
     #
     def extract_outermost_call: (Parser::AST::Node node, Symbol) -> [Parser::AST::Node, Parser::AST::Node?]
+
+    def type_name: (AST::Types::t) -> RBS::TypeName?
+
+    def singleton_type: (AST::Types::t) -> AST::Types::t?
+
+    def instance_type: (AST::Types::t) -> AST::Types::t?
   end
 end

data/sig/steep/type_inference/block_params.rbs

@@ -1,52 +1,154 @@
 module Steep
   module TypeInference
+    # Block parameters have the following differences from method parameters:
+    #
+    # * Allows arity mismatch
+    # * Distributing array-ish argument to parameters
+    # * Allows _multiple_ parameter assignments
+    #
+    # ### Allows arity mismatch
+    #
+    # (TBD)
+    #
+    # ### Distributing array-ish argument to parameters
+    #
+    # A block can receive an array(-ish) argument as follows:
+    # Assume `yield [1,2,3]` evaluates to call the block.
+    #
+    # 1. With one parameter `{|x| ... }` (`x` is `[1, 2, 3]`)
+    # 2. With several parameters (splatting) `{|x, y, z| ... }` (`x` is `1`, ...)
+    #
+    # The splatting applies only when one argument that is an array-ish is yielded.
+    #
+    # Because we have another rule which allows parameter omission, Ruby has another rule to avoid ambiguity.
+    #
+    # 3. One parameter with trailing comma splats `{|x,| ... }` (`x` is `1`)
+    #
+    # The parser has `:procarg0` node for case 1 and `arg` nodes for other cases.
+    #
+    # ### Allows _multiple_ parameter assignments
+    #
     class BlockParams
+      # Param object represents a block parameter
+      #
+      # * `var` is name of the parameter
+      # * `type` is the type of the parameter, if given through inline annotation
+      # * `value` is the default value node
+      # * `node` is the node of the parameter
+      #
       class Param
         attr_reader var: Symbol
 
-        attr_reader type: AST::Types::t
+        attr_reader type: AST::Types::t?
 
-        attr_reader value: untyped
+        attr_reader value: Parser::AST::Node?
 
         attr_reader node: Parser::AST::Node
 
-        def initialize: (var: Symbol, type: AST::Types::t, value: untyped, node: Parser::AST::Node) -> void
+        def initialize: (var: Symbol, type: AST::Types::t?, value: Parser::AST::Node?, node: Parser::AST::Node) -> void
 
         def ==: (untyped other) -> bool
 
         alias eql? ==
 
         def hash: () -> Integer
+
+        def each_param: () { (Param) -> void } -> void
+                      | () -> Enumerator[Param, void]
       end
 
-      attr_reader leading_params: untyped
+      # MultipleParam object represents a _multiple_ block parameter
+      #
+      # ```ruby
+      # foo do |(x, y)|
+      #   #     ^^^^^^  This is the multiple block parameter
+      # end
+      # ```
+      #
+      # * `#node` is `:mlhs` node or `:procarg0` node
+      # * Param objects in `#params` don't have `value` because of Ruby syntax rule
+      #
+      class MultipleParam
+        attr_reader node: Parser::AST::Node
+
+        attr_reader params: Array[Param | MultipleParam]
+
+        def initialize: (node: Parser::AST::Node, params: Array[Param | MultipleParam]) -> void
+
+        def ==: (untyped other) -> bool
+
+        alias eql? ==
+
+        def hash: () -> Integer
+
+        # Returns a hash table that associates variables to its type annotation
+        #
+        def variable_types: () -> Hash[Symbol, AST::Types::t?]
+
+        # Yields Param objects in `self` and it's `params` recursively
+        #
+        def each_param: () { (Param) -> void } -> void
+                      | () -> Enumerator[Param, void]
+      end
+
+      attr_reader leading_params: Array[Param | MultipleParam]
+
+      attr_reader optional_params: Array[Param]
 
-      attr_reader optional_params: untyped
+      attr_reader rest_param: Param?
 
-      attr_reader rest_param: untyped
+      attr_reader trailing_params: Array[Param | MultipleParam]
 
-      attr_reader trailing_params: untyped
+      attr_reader block_param: Param?
 
-      attr_reader block_param: untyped
+      def initialize: (
+        leading_params: Array[Param | MultipleParam],
+        optional_params: Array[Param],
+        rest_param: Param?,
+        trailing_params: Array[Param | MultipleParam],
+        block_param: Param?
+      ) -> void
 
-      def initialize: (leading_params: untyped, optional_params: untyped, rest_param: untyped, trailing_params: untyped, block_param: untyped) -> void
+      def params: () -> Array[Param | MultipleParam]
 
-      def params: () -> untyped
+      def self.from_node: (Parser::AST::Node node, annotations: AST::Annotation::Collection) -> BlockParams
 
-      def self.from_node: (untyped node, annotations: untyped) -> (nil | untyped)
+      def self.from_multiple: (Parser::AST::Node node, AST::Annotation::Collection) -> MultipleParam
 
-      def params_type: (?hint: untyped?) -> untyped
+      def params_type: (?hint: Interface::Function::Params?) -> Interface::Function::Params
 
-      def params_type0: (hint: untyped) -> (nil | untyped)
+      def params_type0: (hint: nil) -> Interface::Function::Params
+                      | (hint: Interface::Function::Params?) -> Interface::Function::Params?
 
-      def zip: (untyped params_type, untyped block) -> untyped
+      def zip: (
+        Interface::Function::Params params_type,
+        Interface::Block? block,
+        factory: AST::Types::Factory
+      ) -> Array[[Param | MultipleParam, AST::Types::t]]
 
-      def expandable_params?: (untyped params_type) -> (untyped | nil)
+      # Returns true if given possible block yields are subject to auto expand/splat
+      #
+      # ```rbs
+      # { (Array[String]) -> void }      # Array[String]
+      # { ([Integer, String]) -> void }  # [Integer, String]
+      # { (String) -> void }             # nil
+      # ```
+      #
+      def expandable_params?: (Interface::Function::Params params_type, AST::Types::Factory) -> AST::Types::t?
 
-      def expandable?: () -> untyped
+      # Returns true if the block is defined to expand/splat automatically
+      #
+      # ```ruby
+      # foo {|x, y| ... }   # true  (has multiple parameters)
+      # foo {|x, *x| ... }  # true  (has normal and rest parameters)
+      # foo {|x,| ... }     # true s(:arg, :x) (has one parameter with trailing comma)
+      # foo {|x| ... }      # false s(:procarg0, s(:arg :x))
+      # ```
+      #
+      def expandable?: () -> bool
 
-      def each: () { (Param) -> void } -> void
-              | () -> Enumerator[Param, void]
+      def each: () { (Param | MultipleParam) -> void } -> void
+              | () -> Enumerator[Param | MultipleParam, void]
     end
   end
 end