steep 1.4.0.dev.1 → 1.4.0.dev.3

data/sig/steep/services/completion_provider.rbs

@@ -51,6 +51,12 @@ module Steep
         attr_reader full_name: RBS::TypeName
 
         def initialize: (env: RBS::Environment, identifier: Symbol, range: Range, type: AST::Types::t, full_name: RBS::TypeName) -> void
+
+        def class?: () -> bool
+
+        def module?: () -> bool
+
+        def comments: () -> Array[RBS::AST::Comment]
       end
 
       class MethodNameItem
@@ -71,6 +77,8 @@ module Steep
         def inherited?: () -> bool
       end
 
+      type item = InstanceVariableItem | LocalVariableItem | ConstantItem | MethodNameItem
+
       attr_reader source_text: String
 
       attr_reader path: Pathname

data/sig/steep/services/hover_provider/rbs.rbs

@@ -5,17 +5,19 @@ module Steep
         class TypeAliasContent
           attr_reader location: ::RBS::Location[untyped, untyped]
 
-          attr_reader decl: ::RBS::AST::Declarations::Alias
+          attr_reader decl: ::RBS::AST::Declarations::TypeAlias
 
-          def initialize: (location: ::RBS::Location[untyped, untyped], decl: ::RBS::AST::Declarations::Alias) -> void
+          def initialize: (location: ::RBS::Location[untyped, untyped], decl: ::RBS::AST::Declarations::TypeAlias) -> void
         end
 
         class ClassContent
           attr_reader location: ::RBS::Location[untyped, untyped]
 
-          attr_reader decl: ::RBS::AST::Declarations::Class | ::RBS::AST::Declarations::Module
+          type decl = ::RBS::AST::Declarations::Class | ::RBS::AST::Declarations::Module | ::RBS::AST::Declarations::ClassAlias | ::RBS::AST::Declarations::ModuleAlias
 
-          def initialize: (location: ::RBS::Location[untyped, untyped], decl: ::RBS::AST::Declarations::Class | ::RBS::AST::Declarations::Module) -> void
+          attr_reader decl: decl
+
+          def initialize: (location: ::RBS::Location[untyped, untyped], decl: decl) -> void
         end
 
         class InterfaceContent

data/sig/steep/services/hover_provider/ruby.rbs

@@ -82,23 +82,27 @@ module Steep
 
           type decl = ::RBS::Environment::ClassEntry
                     | ::RBS::Environment::ModuleEntry
-                    | ::RBS::Environment::SingleEntry[::RBS::TypeName, ::RBS::AST::Declarations::Constant]
+                    | ::RBS::Environment::ClassAliasEntry
+                    | ::RBS::Environment::ModuleAliasEntry
+                    | ::RBS::Environment::ConstantEntry
 
           attr_reader decl: decl
 
           attr_reader class_decl(): ::RBS::Environment::ClassEntry | ::RBS::Environment::ModuleEntry | nil
 
-          attr_reader constant_decl(): ::RBS::Environment::SingleEntry[::RBS::TypeName, ::RBS::AST::Declarations::Constant]?
+          attr_reader class_alias(): ::RBS::Environment::ClassAliasEntry | ::RBS::Environment::ModuleAliasEntry | nil
+
+          attr_reader constant_decl(): ::RBS::Environment::ConstantEntry?
 
           def initialize: (location: Parser::Source::Range, full_name: ::RBS::TypeName, type: AST::Types::t, decl: decl) -> void
 
           def comments: () -> Array[::RBS::AST::Comment]
 
           # Returns true if `decl` is a class/module definition
-          def class_or_module?: () -> (::RBS::Environment::ClassEntry | ::RBS::Environment::ModuleEntry | nil)
+          def class_or_module?: () -> bool
 
           # Returns true if `decl` is a constant definition
-          def constant?: () -> ::RBS::Environment::SingleEntry[::RBS::TypeName, ::RBS::AST::Declarations::Constant]?
+          def constant?: () -> bool
         end
 
         type content = TypeContent | VariableContent | MethodCallContent | DefinitionContent | ConstantContent | TypeAssertionContent

data/sig/steep/services/signature_service.rbs

@@ -1,5 +1,12 @@
 module Steep
   module Services
+    # SignatureService takes care of two sets of RBS files.
+    #
+    # 1. RBS files loaded from `EnvironmentLoader` -- usually type signatures of libraries
+    # 2. RBS files managed in editors -- usually type signatures of the development target (app or gem)
+    #
+    # The files in #2 are managed throuth `#status` and the changes are tracked.
+    #
     class SignatureService
       type status = SyntaxErrorStatus | AncestorErrorStatus | LoadedStatus
 
@@ -65,17 +72,25 @@ module Steep
         def constant_resolver: () -> RBS::Resolver::ConstantResolver
       end
 
+      # A file has one of the three states:
+      #
+      # 1. The parsing succeeded and loaded a list of declarations
+      # 2. The content has a syntax error and parsing failed
+      # 3. Other unexpected error
+      #
       class FileStatus
         attr_reader path: Pathname
 
         attr_reader content: String
 
-        attr_reader decls: Array[RBS::AST::Declarations::t] | Diagnostic::Signature::UnexpectedError | RBS::ParsingError
+        type signature = [RBS::Buffer, Array[RBS::AST::Directives::t], Array[RBS::AST::Declarations::t]]
+
+        attr_reader signature: signature | Diagnostic::Signature::UnexpectedError | RBS::ParsingError
 
         def initialize: (
           path: Pathname,
           content: String,
-          decls: Array[RBS::AST::Declarations::t] | Diagnostic::Signature::UnexpectedError | RBS::ParsingError
+          signature: signature | Diagnostic::Signature::UnexpectedError | RBS::ParsingError
         ) -> void
       end
 
@@ -85,11 +100,17 @@ module Steep
 
       @env_rbs_paths: Set[Pathname]?
 
+      # All RBS paths in environment, both dependency RBS and target RBS
+      #
       def env_rbs_paths: () -> Set[Pathname]
 
+      # Yield all RBS paths in the environment, both dependency RBS and target RBS
+      #
       def each_rbs_path: () { (Pathname) -> void } -> void
                        | () -> Enumerator[Pathname, void]
 
+      # The Target files
+      #
       def files: () -> Hash[Pathname, FileStatus]
 
       def pending_changed_paths: () -> Set[Pathname]
@@ -106,10 +127,13 @@ module Steep
 
       def apply_changes: (Hash[Pathname, FileStatus] files, Server::ChangeBuffer::changes changes) -> Hash[Pathname, FileStatus]
 
+      # The entry point to apply the edit to the signatures
+      #
       def update: (Server::ChangeBuffer::changes changes) -> void
 
       def update_env: (
-        Hash[Pathname, FileStatus] updated_files, paths: Set[Pathname]
+        Hash[Pathname, FileStatus] updated_files,
+        paths: Set[Pathname]
       ) -> (RBS::DefinitionBuilder::AncestorBuilder | Array[Diagnostic::Signature::Base])
 
       def rescue_rbs_error: (Array[RBS::BaseError] errors) { () -> void } -> void

data/sig/steep/services/type_name_completion.rbs

@@ -0,0 +1,122 @@
+use RBS::TypeName, RBS::Namespace, RBS::Environment, RBS::Resolver, RBS::AST::Directives
+
+module Steep
+  module Services
+    class TypeNameCompletion
+      module Prefix
+        type t = nil # no prefix
+               | RawIdentPrefix
+               | NamespacedIdentPrefix
+               | NamespacePrefix
+
+        # Uident or Lident is given, but no `::` (==namespace)
+        #
+        # ```
+        # Str←     Uident
+        # c←       Lident
+        # ```
+        #
+        class RawIdentPrefix
+          attr_reader ident: String
+
+          # Returns true if the `ident` is a Ruby class name
+          #
+          def const_name?: () -> bool
+
+          def initialize: (String ident) -> void
+
+          def size: () -> Integer
+        end
+
+        # Uident or Lident following a namespace
+        #
+        # ```
+        # ::L←         Uident
+        # RBS::Enviro← Uident
+        # ```
+        #
+        class NamespacedIdentPrefix
+          attr_reader namespace: Namespace
+
+          attr_reader ident: String
+
+          def const_name?: () -> bool
+
+          def initialize: (Namespace, String ident, Integer size) -> void
+
+          def size: () -> Integer
+        end
+
+        # Namespace is given
+        #
+        # ```
+        # RBS::←
+        # ::←
+        # ```
+        class NamespacePrefix
+          attr_reader namespace: Namespace
+
+          def initialize: (Namespace, Integer size) -> void
+
+          def size: () -> Integer
+        end
+
+        # line number is 1 origin (Rubyish)
+        #
+        def self.parse: (RBS::Buffer input, line: Integer, column: Integer) -> t
+      end
+
+      class Item
+        # The text to be completed
+        #
+        attr_reader complete_text: String
+
+        # The prefix
+        attr_reader prefix: Prefix::t?
+
+        # Name of the type or constant
+        #
+        attr_reader full_name: TypeName
+
+        # The text to be inserted after the prefix
+        #
+        def insert_text: () -> String
+
+        def initialize: (prefix: Prefix::t?, full_name: TypeName, complete_text: String) -> void
+      end
+
+      attr_reader env: Environment
+
+      attr_reader context: Resolver::context
+
+      attr_reader type_name_resolver: Resolver::TypeNameResolver
+
+      attr_reader map: Environment::UseMap
+
+      def initialize: (env: Environment, context: Resolver::context, dirs: Array[Directives::t]) -> void
+
+      def complete_class_name: (RBS::Buffer input, line: Integer, column: Integer) -> Array[Item]
+
+      # Find type names from the context for RBS
+      #
+      # Doesn't take account of ancestors of the context.
+      #
+      def find_type_names: (Prefix::t) -> Array[TypeName]
+
+      # Returns a pair of
+      #
+      # * Absolute type name
+      # * Relative type name in given context if possible (or absolute name)
+      #
+      def resolve_name_in_context: (TypeName) -> [TypeName, TypeName]
+
+      def format_constant_name: (TypeName) -> String
+
+      def each_type_name: () { (TypeName) -> void } -> void
+                        | () -> Enumerator[TypeName, void]
+
+      def each_outer_module: (?Resolver::context) { (Namespace) -> void } -> Namespace
+                           | () -> Enumerator[Namespace, void]
+    end
+  end
+end

data/sig/steep/signature/validator.rbs

@@ -9,7 +9,7 @@ module Steep
 
       @errors: Array[Diagnostic::Signature::Base]
 
-      @type_name_resolver: RBS::TypeNameResolver?
+      @type_name_resolver: RBS::Resolver::TypeNameResolver?
 
       @validator: RBS::Validator?
 
@@ -26,7 +26,7 @@ module Steep
 
       def builder: () -> RBS::DefinitionBuilder
 
-      def type_name_resolver: () -> RBS::TypeNameResolver
+      def type_name_resolver: () -> RBS::Resolver::TypeNameResolver
 
       def validator: () -> RBS::Validator
 
@@ -60,13 +60,17 @@ module Steep
 
       def validate_const: () -> void
 
-      def validate_one_constant: (RBS::TypeName name, RBS::Environment::SingleEntry[RBS::TypeName, RBS::AST::Declarations::Constant] entry) -> void
+      def validate_one_constant: (RBS::TypeName name, RBS::Environment::ConstantEntry entry) -> void
 
       def validate_global: () -> void
 
-      def validate_one_global: (Symbol name, RBS::Environment::SingleEntry[Symbol, RBS::AST::Declarations::Global]) -> void
+      def validate_one_global: (Symbol name, RBS::Environment::GlobalEntry) -> void
 
-      def validate_one_alias: (RBS::TypeName name, ?RBS::Environment::SingleEntry[RBS::TypeName, RBS::AST::Declarations::Alias] entry) -> void
+      def validate_one_alias: (RBS::TypeName name, ?RBS::Environment::TypeAliasEntry entry) -> void
+
+      def validate_one_class_decl: (RBS::TypeName) -> void
+                                 
+      def validate_one_class_alias: (RBS::TypeName, RBS::Environment::ClassAliasEntry | RBS::Environment::ModuleAliasEntry) -> void
 
       def validate_alias: () -> void
 

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.
@@ -80,9 +82,9 @@ module Steep
 
     def with_method_constr: (untyped method_name, untyped node, args: untyped, self_type: untyped, definition: untyped) { (untyped) -> untyped } -> untyped
 
-    def implement_module: (module_name: untyped, annotations: untyped, ?super_name: untyped?) -> untyped
+    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/constant_env.rbs

@@ -21,6 +21,8 @@ module Steep
 
       def children: (RBS::TypeName module_name) -> Hash[Symbol, constant_tuple]
 
+      def decompose_constant!: (RBS::Constant? constant) -> constant_tuple
+
       def decompose_constant: (RBS::Constant? constant) -> constant_tuple?
     end
   end