steep 1.5.0.pre.5 → 1.5.0.pre.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ed79428764aa83fbd2e7f3c5a8e52ff863b4e65bef05aae43ba9ca4b7c9d2f4e
-  data.tar.gz: be79772ce19f152e3048ae565802640cae96f1bfca98adf60eab47a28ab3ccad
+  metadata.gz: d00242c259b7c8d2a4a0f7022874ac5bb5f08491ab3edade6165ff1a9fbe89a7
+  data.tar.gz: e02d896359c4eb88c730601320bb9137342c19b9ad1956d4ac417ffa5926d74a
 SHA512:
-  metadata.gz: aa071be8eaf425a2a36ffed4c8d0a97446997f9cbf85c9dc4190b5bf26c9bf5f66c7106ab27b96378d05e246a6327689ef491dedbd16ad7cb9eb8d8079b3818d
-  data.tar.gz: d7f842d51c84a2f48bdfd79a07de3e6265dd746497aa9661871f12b062832c2a24f46b37ce1ddb614ac5ba1c65f4c408e9e1eafec27fd69d7158514fe77e0fec
+  metadata.gz: 5be83d84d984d215342c030e9ea590c419a1e12963361266f4bc57e2b2ceec110a3f08313754b2f46a274fc8b0d2acca497c71f2eff24c3fd4505cb1ff2ac5a7
+  data.tar.gz: 7a30b064aa7ec6e27e3811e93b1ddf7ff4824cdeb5dfe70075f34311f7e22016bf4f3a2b107307a5247c54532451a25155fc2ba277842fec85f71aa23fdaced1

data/CHANGELOG.md

@@ -2,6 +2,24 @@
 
 ## master
 
+## 1.5.0.pre.6 (2023-07-11)
+
+### Type checker core
+
+* Report RBS validation errors in Ruby code ([#859](https://github.com/soutaro/steep/pull/859))
+* Fix proc type assignment ([#858](https://github.com/soutaro/steep/pull/858))
+* Report `UnexpectedKeywordArgument` even if no keyword param is accepted ([#856](https://github.com/soutaro/steep/pull/856))
+* Unfold type alias on unwrap optional ([#855](https://github.com/soutaro/steep/pull/855))
+
+### Language server
+
+* Keyword completion in block call ([#865](https://github.com/soutaro/steep/pull/865))
+* Indicate the current or next argument on signature help ([#850](https://github.com/soutaro/steep/pull/850))
+* Support completion for keyword arguments ([#851](https://github.com/soutaro/steep/pull/851))
+* Let hover show the type of method call node ([#864](https://github.com/soutaro/steep/pull/864))
+* Fix UnknownNodeError in SignatureHelp ([#863](https://github.com/soutaro/steep/pull/863))
+* hover: Fix NoMethodError on generating hover for not supported files ([#853](https://github.com/soutaro/steep/pull/853))
+
 ## 1.5.0.pre.5 (2023-07-07)
 
 ### Type checker core

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    steep (1.5.0.pre.5)
+    steep (1.5.0.pre.6)
       activesupport (>= 5.1)
       concurrent-ruby (>= 1.1.10)
       csv (>= 3.0.9)

data/lib/steep/ast/node/type_application.rb

@@ -37,10 +37,12 @@ module Steep
             ty = ty.map_type_name {|name| resolver.resolve(name, context: context) || name.absolute! }
 
             validator = Signature::Validator.new(checker: subtyping)
-            validator.validate_type(ty)
+            validator.rescue_validation_errors do
+              validator.validate_type(ty)
+            end
 
             if validator.has_error?
-              return
+              return validator.each_error
             end
 
             ty = subtyping.factory.type(ty)
@@ -58,7 +60,7 @@ module Steep
 
         def types?(context, subtyping, type_vars)
           case types = types(context, subtyping, type_vars)
-          when RBS::ParsingError
+          when RBS::ParsingError, Enumerator
             nil
           else
             types

data/lib/steep/ast/node/type_assertion.rb

@@ -22,10 +22,14 @@ module Steep
             ty = ty.map_type_name {|name| resolver.resolve(name, context: context) || name.absolute! }
 
             validator = Signature::Validator.new(checker: subtyping)
-            validator.validate_type(ty)
+            validator.rescue_validation_errors do
+              validator.validate_type(ty)
+            end
 
             unless validator.has_error?
               subtyping.factory.type(ty)
+            else
+              validator.each_error.to_a
             end
           else
             nil
@@ -37,7 +41,7 @@ module Steep
         def type_syntax?
           RBS::Parser.parse_type(type_location.buffer, range: type_location.range, variables: [], require_eof: true)
           true
-        rescue::RBS::ParsingError
+        rescue ::RBS::ParsingError
           false
         end
 
@@ -45,7 +49,7 @@ module Steep
           type = type(context, subtyping, type_vars)
 
           case type
-          when RBS::ParsingError, nil
+          when RBS::ParsingError, nil, Array
             nil
           else
             type

data/lib/steep/ast/types/factory.rb

@@ -401,6 +401,13 @@ module Steep
             end
           when AST::Types::Nil
             nil
+          when AST::Types::Name::Alias
+            type_ = expand_alias(type)
+            if type_ == type
+              type_
+            else
+              unwrap_optional(type_)
+            end
           else
             type
           end

data/lib/steep/diagnostic/ruby.rb

@@ -964,6 +964,19 @@ module Steep
         end
       end
 
+      class RBSError < Base
+        attr_reader :error
+
+        def initialize(error:, node:, location:)
+          @error = error
+          super(node: node, location: location)
+        end
+
+        def header_line
+          error.header_line
+        end
+      end
+
       ALL = ObjectSpace.each_object(Class).with_object([]) do |klass, array|
         if klass < Base
           array << klass

data/lib/steep/node_helper.rb

@@ -217,5 +217,28 @@ module Steep
         false
       end
     end
+
+    def deconstruct_sendish_and_block_nodes(*nodes)
+      send_node, block_node = nodes.take(2)
+
+      if send_node
+        case send_node.type
+        when :send, :csend, :super
+          if block_node
+            case block_node.type
+            when :block, :numblock
+              if send_node.equal?(block_node.children[0])
+                return [send_node, block_node]
+              end
+            end
+          end
+
+          [send_node, nil]
+        when :zsuper
+          # zsuper doesn't receive block
+          [send_node, nil]
+        end
+      end
+    end
   end
 end

data/lib/steep/server/interaction_worker.rb

@@ -361,6 +361,17 @@ module Steep
               new_text: item.identifier.to_s
             )
           )
+        when Services::CompletionProvider::KeywordArgumentItem
+          LSP::Interface::CompletionItem.new(
+            label: item.identifier.to_s,
+            kind: LSP::Constant::CompletionItemKind::FIELD,
+            label_details: LSP::Interface::CompletionItemLabelDetails.new(description: 'Keyword argument'),
+            documentation: LSPFormatter.markup_content { LSPFormatter.format_completion_docs(item) },
+            text_edit: LSP::Interface::TextEdit.new(
+              range: range,
+              new_text: item.identifier.to_s
+            )
+          )
         when Services::CompletionProvider::TypeNameItem
           kind =
             case
@@ -397,6 +408,8 @@ module Steep
               signatures = items.map do |item|
                 LSP::Interface::SignatureInformation.new(
                   label: "(#{item.method_type.type.param_to_s})",
+                  parameters: item.parameters.map { |param| LSP::Interface::ParameterInformation.new(label: param)},
+                  active_parameter: item.active_parameter,
                   documentation: item.comment&.yield_self do |comment|
                     LSP::Interface::MarkupContent.new(
                       kind: LSP::Constant::MarkupKind::MARKDOWN,

data/lib/steep/server/lsp_formatter.rb

@@ -28,7 +28,16 @@ module Steep
 
           case call
           when TypeInference::MethodCall::Typed
+            io.puts <<~MD
+              ```rbs
+              #{call.actual_method_type.type.return_type}
+              ```
+
+              ----
+            MD
+
             method_types = call.method_decls.map(&:method_type)
+
             if call.is_a?(TypeInference::MethodCall::Special)
               method_types = [
                 call.actual_method_type.with(
@@ -250,6 +259,10 @@ module Steep
           end
 
           io.string
+        when Services::CompletionProvider::KeywordArgumentItem
+          <<~MD
+            **Keyword argument**: `#{item.identifier}`
+          MD
         end
       end
 

data/lib/steep/services/completion_provider.rb

@@ -1,6 +1,8 @@
 module Steep
   module Services
     class CompletionProvider
+      include NodeHelper
+
       Position = _ = Struct.new(:line, :column, keyword_init: true) do
         # @implements Position
         def -(size)
@@ -11,6 +13,7 @@ module Steep
       Range = _ = Struct.new(:start, :end, keyword_init: true)
 
       InstanceVariableItem = _ = Struct.new(:identifier, :range, :type, keyword_init: true)
+      KeywordArgumentItem = _ = Struct.new(:identifier, :range, keyword_init: true)
       LocalVariableItem = _ = Struct.new(:identifier, :range, :type, keyword_init: true)
       ConstantItem = _ = Struct.new(:env, :identifier, :range, :type, :full_name, keyword_init: true) do
         # @implements ConstantItem
@@ -267,7 +270,9 @@ module Steep
               []
             end
           else
-            []
+            items = [] #: Array[item]
+            items_for_following_keyword_arguments(source_text, index: index, line: line, column: column, items: items)
+            items
           end
         end
       end
@@ -302,10 +307,10 @@ module Steep
       end
 
       def items_for_trigger(position:)
-        node, *_parents = source.find_nodes(line: position.line, column: position.column)
+        node, *parents = source.find_nodes(line: position.line, column: position.column)
         node ||= source.node
 
-        return [] unless node
+        return [] unless node && parents
 
         items = [] #: Array[item]
 
@@ -319,6 +324,16 @@ module Steep
           method_items_for_receiver_type(context.self_type, include_private: true, prefix: prefix, position: position, items: items)
           local_variable_items_for_context(context, position: position, prefix: prefix, items: items)
 
+          if (send_node, block_node = deconstruct_sendish_and_block_nodes(*parents))
+            keyword_argument_items_for_method(
+              call_node: block_node || send_node,
+              send_node: send_node,
+              position: position,
+              prefix: prefix,
+              items: items
+            )
+          end
+
         when node.type == :lvar && at_end?(position, of: node.loc)
           # foo ← (lvar)
           local_variable_items_for_context(context, position: position, prefix: node.children[0].to_s, items: items)
@@ -527,6 +542,37 @@ module Steep
         items
       end
 
+      def items_for_following_keyword_arguments(text, index:, line:, column:, items:)
+        return if text[index - 1] !~ /[a-zA-Z0-9]/
+
+        text = text.dup
+        argname = [] #: Array[String]
+        while text[index - 1] =~ /[a-zA-Z0-9]/
+          argname.unshift(text[index - 1] || '')
+          source_text[index - 1] = " "
+          index -= 1
+        end
+
+        begin
+          type_check!(source_text, line: line, column: column)
+        rescue Parser::SyntaxError
+          return
+        end
+
+        if nodes = source.find_nodes(line: line, column: column)
+          if (send_node, block_node = deconstruct_sendish_and_block_nodes(*nodes))
+            position = Position.new(line: line, column: column)
+            keyword_argument_items_for_method(
+              call_node: block_node || send_node,
+              send_node: send_node,
+              position: position,
+              prefix: argname.join,
+              items: items
+            )
+          end
+        end
+      end
+
       def method_items_for_receiver_type(type, include_private:, prefix:, position:, items:)
         range = range_for(position, prefix: prefix)
         context = typing.context_at(line: position.line, column: position.column)
@@ -641,6 +687,42 @@ module Steep
         end
       end
 
+      def keyword_argument_items_for_method(call_node:, send_node:, position:, prefix:, items:)
+        receiver_node, method_name, argument_nodes = deconstruct_send_node!(send_node)
+
+        call = typing.call_of(node: call_node)
+
+        case call
+        when TypeInference::MethodCall::Typed, TypeInference::MethodCall::Error
+          type = call.receiver_type
+          shape = subtyping.builder.shape(
+            type,
+            public_only: !!receiver_node,
+            config: Interface::Builder::Config.new(self_type: type, class_type: nil, instance_type: nil, variable_bounds: {})
+          )
+          if shape
+            if method = shape.methods[call.method_name]
+              method.method_types.each.with_index do |method_type, i|
+                defn = method_type.method_decls.to_a[0]&.method_def
+                if defn
+                  range = range_for(position, prefix: prefix)
+                  kwargs = argument_nodes.find { |arg| arg.type == :kwargs }&.children || []
+                  used_kwargs = kwargs.filter_map { |arg| arg.type == :pair && arg.children.first.children.first }
+
+                  kwargs = defn.type.type.required_keywords.keys + defn.type.type.optional_keywords.keys
+                  kwargs.each do |name|
+                    if name.to_s.start_with?(prefix) && !used_kwargs.include?(name)
+                      items << KeywordArgumentItem.new(identifier: "#{name}:", range: range)
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+
+
       def index_for(string, line:, column:)
         index = 0
 

data/lib/steep/services/hover_provider/ruby.rb

@@ -110,7 +110,7 @@ module Steep
         end
 
         def content_for(target:, path:, line:, column:)
-          file = service.source_files[path]
+          file = service.source_files[path] or return
           typing = typecheck(target, path: path, content: file.content, line: line, column: column) or return
           node, *parents = typing.source.find_nodes(line: line, column: column)
 

data/lib/steep/services/signature_help_provider.rb

@@ -3,7 +3,21 @@ module Steep
     class SignatureHelpProvider
       MethodCall = TypeInference::MethodCall
 
-      Item = _ = Struct.new(:method_type, :comment)
+      Item = _ = Struct.new(:method_type, :comment, :active_parameter) do
+        # @implements Item
+
+        def parameters
+          arguments = [] #: Array[String]
+          arguments.push(*method_type.type.required_positionals.map(&:to_s))
+          arguments.push(*method_type.type.optional_positionals.map {|p| "?#{p}"})
+          arguments.push("*#{self.method_type.type.rest_positionals}") if method_type.type.rest_positionals
+          arguments.push(*method_type.type.trailing_positionals.map(&:to_s))
+          arguments.push(*method_type.type.required_keywords.map {|name, param| "#{name}: #{param}" })
+          arguments.push(*method_type.type.optional_keywords.map {|name, param| "?#{name}: #{param}" })
+          arguments.push("**#{method_type.type.rest_keywords}") if method_type.type.rest_keywords
+          arguments
+        end
+      end
 
       attr_reader :source, :path, :subtyping, :typing, :buffer
 
@@ -23,12 +37,14 @@ module Steep
         return unless nodes
 
         typing = type_check!(line: line, column: column)
+        argument_nodes = [] #: Array[Parser::AST::Node]
 
         while true
           node = nodes.shift()
           parent = nodes.first
 
           node or return
+          argument_nodes << node
 
           if node.type == :send || node.type == :csend
             pos = buffer.loc_to_pos([line, column])
@@ -40,12 +56,13 @@ module Steep
                 # Given position is between open/close parens of args of send node
 
                 if parent && (parent.type == :block || parent.type == :numblock)
-                  send_node = parent.children[0]
+                  send_node = parent
                 else
                   send_node = node
                 end
 
-                return signature_help_for(send_node, typing)
+                last_argument_nodes = last_argument_nodes_for(argument_nodes: argument_nodes, line: line, column: column)
+                return signature_help_for(send_node, argument_nodes, last_argument_nodes, typing)
               end
             end
           end
@@ -58,7 +75,24 @@ module Steep
         TypeCheckService.type_check(source: source, subtyping: subtyping, constant_resolver: resolver)
       end
 
-      def signature_help_for(node, typing)
+      def last_argument_nodes_for(argument_nodes:, line:, column:)
+        return unless argument_nodes.last.children[2]  # No arguments
+        return argument_nodes if argument_nodes.size > 1  # Cursor is on the last argument
+
+        pos = buffer.loc_to_pos([line, column])
+
+        while true
+          pos -= 1
+          line, column = buffer.pos_to_loc(pos)
+          nodes = source.find_nodes(line: line, column: column)
+          return unless nodes
+
+          index = nodes.index { |n| n.type == :send || n.type == :csend }
+          return nodes[..index] if index.to_i > 0
+        end
+      end
+
+      def signature_help_for(node, argument, last_argument, typing)
         call = typing.call_of(node: node)
         context = typing.context_at(line: node.loc.expression.line, column: node.loc.expression.column)
 
@@ -82,7 +116,8 @@ module Steep
               method.method_types.each.with_index do |method_type, i|
                 defn = method_type.method_decls.to_a[0]&.method_def
 
-                items << Item.new(subtyping.factory.method_type_1(method_type), defn&.comment)
+                active_parameter = active_parameter_for(defn&.type, argument, last_argument, node)
+                items << Item.new(subtyping.factory.method_type_1(method_type), defn&.comment, active_parameter)
 
                 if call.is_a?(MethodCall::Typed)
                   if method_type.method_decls.intersect?(call.method_decls)
@@ -98,6 +133,66 @@ module Steep
 
         [items, index]
       end
+
+      def active_parameter_for(method_type, argument_nodes, last_argument_nodes, node)
+        return unless method_type
+
+        positionals = method_type.type.required_positionals.size + method_type.type.optional_positionals.size + (method_type.type.rest_positionals ? 1 : 0) + method_type.type.trailing_positionals.size
+
+        if argument_nodes.size == 1
+          # Cursor is not on the argument (maybe on comma after argument)
+          return 0 if last_argument_nodes.nil?  # No arguments
+
+          case last_argument_nodes[-2].type
+          when :splat
+            method_type.type.required_positionals.size + method_type.type.optional_positionals.size + 1 if method_type.type.rest_positionals
+          when :kwargs
+            case last_argument_nodes[-3].type
+            when :pair
+              argname = last_argument_nodes[-3].children.first.children.first
+              if method_type.type.required_keywords[argname]
+                positionals + method_type.type.required_keywords.keys.index(argname).to_i + 1
+              elsif method_type.type.optional_keywords[argname]
+                positionals + method_type.type.required_keywords.size + method_type.type.optional_keywords.keys.index(argname).to_i + 1
+              elsif method_type.type.rest_keywords
+                positionals + method_type.type.required_keywords.size + method_type.type.optional_keywords.size
+              end
+            when :kwsplat
+              positionals + method_type.type.required_keywords.size + method_type.type.optional_keywords.size if method_type.type.rest_keywords
+            end
+          else
+            pos = node.children[2...].index { |c| c.location == last_argument_nodes[-2].location }.to_i
+            if method_type.type.rest_positionals
+              [pos + 1, positionals - 1].min
+            else
+              [pos + 1, positionals].min
+            end
+          end
+        else
+          # Cursor is on the argument
+          case argument_nodes[-2].type
+          when :splat
+            method_type.type.required_positionals.size + method_type.type.optional_positionals.size if method_type.type.rest_positionals
+          when :kwargs
+            case argument_nodes[-3].type
+            when :pair
+              argname = argument_nodes[-3].children.first.children.first
+              if method_type.type.required_keywords[argname]
+                positionals + method_type.type.required_keywords.keys.index(argname).to_i
+              elsif method_type.type.optional_keywords[argname]
+                positionals + method_type.type.required_keywords.size + method_type.type.optional_keywords.keys.index(argname).to_i
+              elsif method_type.type.rest_keywords
+                positionals + method_type.type.required_keywords.size + method_type.type.optional_keywords.size
+              end
+            when :kwsplat
+              positionals + method_type.type.required_keywords.size + method_type.type.optional_keywords.size if method_type.type.rest_keywords
+            end
+          else
+            pos = node.children[2...].index { |c| c.location == argument_nodes[-2].location }.to_i
+            [pos, positionals - 1].min
+          end
+        end
+      end
     end
   end
 end

data/lib/steep/type_construction.rb

@@ -1950,10 +1950,6 @@ module Steep
               branch_results = [] #: Array[Pair]
 
               cond_type, constr = constr.synthesize(cond)
-              _, cond_vars = interpreter.decompose_value(cond)
-              SPECIAL_LVAR_NAMES.each do |name|
-                cond_vars.delete(name)
-              end
 
               var_name = :"_a[#{SecureRandom.alphanumeric(4)}]"
               var_cond, value_node = transform_condition_node(cond, var_name)
@@ -2621,7 +2617,26 @@ module Steep
             # @type var as_type: AST::Node::TypeAssertion
             asserted_node, as_type = node.children
 
-            if type = as_type.type?(module_context.nesting, checker, [])
+            type = as_type.type(module_context.nesting, checker, [])
+
+            case type
+            when Array
+              type.each do |error|
+                typing.add_error(
+                  Diagnostic::Ruby::RBSError.new(
+                    error: error,
+                    node: node,
+                    location: error.location || raise
+                  )
+                )
+              end
+
+              synthesize(asserted_node, hint: hint)
+
+            when nil, RBS::ParsingError
+              synthesize(asserted_node, hint: hint)
+
+            else
               actual_type, constr = synthesize(asserted_node, hint: type)
 
               if no_subtyping?(sub_type: type, super_type: actual_type) && no_subtyping?(sub_type: actual_type, super_type: type)
@@ -2635,22 +2650,34 @@ module Steep
               end
 
               constr.add_typing(node, type: type)
-            else
-              synthesize(asserted_node, hint: hint)
             end
           end
 
-        when :block, :numblock, :send, :csend
-          synthesize_sendish(node, hint: hint, tapp: nil)
-
         when :tapp
           yield_self do
+            # @type var tapp: AST::Node::TypeApplication
             sendish, tapp = node.children
+
+            if (array = tapp.types(module_context.nesting, checker, [])).is_a?(Enumerator)
+              array.each do |error|
+                typing.add_error(
+                  Diagnostic::Ruby::RBSError.new(
+                    error: error,
+                    node: node,
+                    location: error.location || raise
+                  )
+                )
+              end
+            end
+
             type, constr = synthesize_sendish(sendish, hint: hint, tapp: tapp)
 
             constr.add_typing(node, type: type)
           end
 
+        when :block, :numblock, :send, :csend
+          synthesize_sendish(node, hint: hint, tapp: nil)
+
         when :forwarded_args, :forward_arg
           add_typing(node, type: AST::Builtin.any_type)
 
@@ -3077,7 +3104,8 @@ module Steep
         type_hint = deep_expand_alias(type_hint) || type_hint
 
         procs = flatten_union(type_hint).select do |type|
-          check_relation(sub_type: type, super_type: AST::Builtin::Proc.instance_type).success?
+          check_relation(sub_type: type, super_type: AST::Builtin::Proc.instance_type).success? &&
+            !type.is_a?(AST::Types::Any)
         end
 
         proc_instances, proc_types = procs.partition {|type| AST::Builtin::Proc.instance_type?(type) }

data/lib/steep/type_inference/send_args.rb

@@ -681,7 +681,15 @@ module Steep
             when KeywordArgs::MissingKeyword
               missing_keywords.push(*error.keywords.to_a)
             when PositionalArgs::UnexpectedArg
-              diagnostics << Diagnostic::Ruby::UnexpectedPositionalArgument.new(node: error.node, params: params)
+              if error.node.type == :kwargs
+                error.node.children.each do |kwarg|
+                  if kwarg.type == :pair
+                    diagnostics << Diagnostic::Ruby::UnexpectedKeywordArgument.new(node: kwarg, params: params)
+                  end
+                end
+              else
+                diagnostics << Diagnostic::Ruby::UnexpectedPositionalArgument.new(node: error.node, params: params)
+              end
             when PositionalArgs::MissingArg
               diagnostics << Diagnostic::Ruby::InsufficientPositionalArguments.new(node: node, params: params)
             end

data/lib/steep/version.rb

@@ -1,3 +1,3 @@
 module Steep
-  VERSION = "1.5.0.pre.5"
+  VERSION = "1.5.0.pre.6"
 end

data/sig/steep/ast/node/type_application.rbs

@@ -12,7 +12,7 @@ module Steep
 
         def initialize: (RBS::Location[untyped, untyped]) -> void
 
-        def types: (RBS::Resolver::context, Subtyping::Check, Array[Symbol] type_vars) -> (Array[Types::t] | RBS::ParsingError | nil)
+        def types: (RBS::Resolver::context, Subtyping::Check, Array[Symbol] type_vars) -> (Array[Types::t] | RBS::ParsingError | Enumerator[Diagnostic::Signature::Base, void] | nil)
 
         def types?: (RBS::Resolver::context, Subtyping::Check, Array[Symbol] type_vars) -> Array[Types::t]?
 

data/sig/steep/ast/node/type_assertion.rbs

@@ -10,7 +10,7 @@ module Steep
 
         def initialize: (RBS::Location[untyped, untyped]) -> void
 
-        def type: (RBS::Resolver::context, Subtyping::Check, Array[Symbol] type_vars) -> (Types::t | RBS::ParsingError | nil)
+        def type: (RBS::Resolver::context, Subtyping::Check, Array[Symbol] type_vars) -> (Types::t | RBS::ParsingError | Array[Diagnostic::Signature::Base] | nil)
 
         def type?: (RBS::Resolver::context, Subtyping::Check, Array[Symbol] type_vars) -> Types::t?
 

data/sig/steep/diagnostic/ruby.rbs

@@ -495,7 +495,7 @@ module Steep
       # ```
       #
       # This diagnostic allows writing `raise` or `return`, by checking the type of the branch body is `bot` or not.
-      # 
+      #
       class UnreachableValueBranch < Base
         attr_reader type: AST::Types::t
 
@@ -622,6 +622,14 @@ module Steep
         def initialize: (hint_type: AST::Types::t, node: Parser::AST::Node) -> void
       end
 
+      # RBS embedded in the Ruby code has validation error
+      # 
+      class RBSError < Base
+        attr_reader error: Signature::Base
+
+        def initialize: (error: Signature::Base, node: Parser::AST::Node, location: location) -> void
+      end
+
       # Argument forwarding `...` cannot be done safely, because of
       #
       # 1. The arguments are incompatible, or

data/sig/steep/node_helper.rbs

@@ -65,5 +65,14 @@ module Steep
     def deconstruct_send_node!: (Node) -> [Node?, Symbol, Array[Node], send_loc]
 
     def test_send_node: (Node) { (Node?, Symbol, Array[Node], send_loc) -> bool } -> bool
+
+    # Deconstruct sendish node and it's associated block node
+    #
+    # Receives a sequence of node tree where the leaf node comes first.
+    # If the first node is `send`, `csend`, `super`, or `zsuper`, it is the sendish node.
+    #
+    # If the next node is a `block` or `numblock` that is associated to the *sendish node*, it is the block node.
+    #
+    def deconstruct_sendish_and_block_nodes: (*Parser::AST::Node) -> [Parser::AST::Node, Parser::AST::Node?]?
   end
 end

data/sig/steep/services/completion_provider.rbs

@@ -4,6 +4,8 @@ use Steep::TypeInference::MethodCall
 module Steep
   module Services
     class CompletionProvider
+      include NodeHelper
+
       # Cursor position
       class Position
         attr_reader line: Integer
@@ -33,6 +35,14 @@ module Steep
         def initialize: (identifier: Symbol, range: Range, type: AST::Types::t) -> void
       end
 
+      class KeywordArgumentItem
+        attr_reader identifier: String
+
+        attr_reader range: Range
+
+        def initialize: (identifier: String, range: Range) -> void
+      end
+
       class LocalVariableItem
         attr_reader identifier: Symbol
 
@@ -169,6 +179,7 @@ module Steep
       end
 
       type item = InstanceVariableItem
+                | KeywordArgumentItem
                 | LocalVariableItem
                 | ConstantItem
                 | SimpleMethodNameItem
@@ -216,6 +227,8 @@ module Steep
 
       def items_for_rbs: (position: Position, buffer: RBS::Buffer) -> Array[item]
 
+      def items_for_following_keyword_arguments: (String text, index: Integer, line: Integer, column: Integer, items: Array[item]) -> void
+
       def method_items_for_receiver_type: (AST::Types::t, include_private: bool, prefix: String, position: Position, items: Array[item]) -> void
 
       def word_name?: (String name) -> bool
@@ -226,12 +239,13 @@ module Steep
 
       def instance_variable_items_for_context: (TypeInference::Context context, position: Position, prefix: String, items: Array[item]) -> void
 
+      def keyword_argument_items_for_method: (call_node: Parser::AST::Node, send_node: Parser::AST::Node, position: Position, prefix: String, items: Array[item]) -> void
+
       def index_for: (String, line: Integer, column: Integer) -> Integer
 
       def disallowed_method?: (Symbol name) -> bool
 
       def unwrap_optional: (AST::Types::t) -> AST::Types::t
-
     end
   end
 end

data/sig/steep/services/signature_help_provider.rbs

@@ -10,7 +10,11 @@ module Steep
 
         attr_reader comment: RBS::AST::Comment?
 
-        def initialize: (RBS::MethodType, RBS::AST::Comment?) -> void
+        attr_reader active_parameter: Integer?
+
+        def initialize: (RBS::MethodType, RBS::AST::Comment?, Integer?) -> void
+
+        def parameters: () -> Array[String]
       end
 
       attr_reader source: Source
@@ -31,7 +35,13 @@ module Steep
 
       private
 
-      def signature_help_for: (Parser::AST::Node, Typing) -> [Array[Item], Integer?]?
+      def active_parameter_for: (RBS::MethodType?, Array[Parser::AST::Node], Array[Parser::AST::Node]?, Parser::AST::Node) -> Integer?
+
+      def arguments_for: (RBS::MethodType) -> Array[String]
+
+      def last_argument_nodes_for: (argument_nodes: Array[Parser::AST::Node], line: Integer, column: Integer) -> Array[Parser::AST::Node]?
+
+      def signature_help_for: (Parser::AST::Node, Array[Parser::AST::Node], Array[Parser::AST::Node]?, Typing) -> [Array[Item], Integer?]?
 
       def type_check!: (line: Integer, column: Integer) -> Typing
     end

data/sig/steep/signature/validator.rbs

@@ -38,7 +38,7 @@ module Steep
 
       def validate_type_application: (RBS::Types::t) -> void
 
-      def validate_type: (RBS::Types::t `type`) -> untyped
+      def validate_type: (RBS::Types::t `type`) -> void
 
       def ancestor_to_type: (RBS::Definition::Ancestor::t ancestor) -> (AST::Types::Name::Interface | AST::Types::Name::Instance)
 
@@ -69,7 +69,7 @@ module Steep
       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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: steep
 version: !ruby/object:Gem::Version
-  version: 1.5.0.pre.5
+  version: 1.5.0.pre.6
 platform: ruby
 authors:
 - Soutaro Matsumoto
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-07-07 00:00:00.000000000 Z
+date: 2023-07-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parser