steep 1.5.0.pre.4 → 1.5.0.pre.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cfb1de89ec50042cf06306ab17717671e8b6a8451ea2885b4af8085226f7994e
-  data.tar.gz: 1b67eb25821061afe42c8c4dd644b30370e866ac9ef8066cb77031799c981145
+  metadata.gz: d00242c259b7c8d2a4a0f7022874ac5bb5f08491ab3edade6165ff1a9fbe89a7
+  data.tar.gz: e02d896359c4eb88c730601320bb9137342c19b9ad1956d4ac417ffa5926d74a
 SHA512:
-  metadata.gz: 1f0b3400822be747c45ed1d5c2cdfbddf8c0fdf70963061b66308464a18a95e493cc94ad406bbc444f618f562e0f95f276600c27e3ec2269f01504727b0528c7
-  data.tar.gz: 45b2a32802ea5ab504a8c3ee04f714a87b27227ffa66282d64243e3161aa0628001f1925e3ad7aaf09fcd0fbddc4def36e9b9940c76a87b195c2f51b19006bf9
+  metadata.gz: 5be83d84d984d215342c030e9ea590c419a1e12963361266f4bc57e2b2ceec110a3f08313754b2f46a274fc8b0d2acca497c71f2eff24c3fd4505cb1ff2ac5a7
+  data.tar.gz: 7a30b064aa7ec6e27e3811e93b1ddf7ff4824cdeb5dfe70075f34311f7e22016bf4f3a2b107307a5247c54532451a25155fc2ba277842fec85f71aa23fdaced1

data/CHANGELOG.md

@@ -2,6 +2,31 @@
 
 ## 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
+
+* Unreachability improvements ([#845](https://github.com/soutaro/steep/pull/845))
+* Fix type inference problem ([#843](https://github.com/soutaro/steep/pull/843))
+
 ## 1.5.0.pre.4 (2023-07-06)
 
 ### Type checker core

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    steep (1.5.0.pre.4)
+    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

@@ -204,7 +204,7 @@ module Steep
           when Logic::Base
             RBS::Types::Bases::Bool.new(location: type.location)
           else
-            __skip__ = raise "Unexpected type given: #{type} (#{type.class})"
+            raise "Unexpected type given: #{type} (#{type.class})"
           end
         end
 
@@ -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

@@ -767,6 +767,19 @@ module Steep
         end
       end
 
+      class UnreachableValueBranch < Base
+        attr_reader :type
+
+        def initialize(node:, type:, location: node.location.expression)
+          super(node: node, location: location)
+          @type = type
+        end
+
+        def header_line
+          "The branch may evaluate to a value of `#{type}` but unreachable"
+        end
+      end
+
       class UnexpectedSplat < Base
         attr_reader :type
 
@@ -951,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
@@ -968,7 +994,8 @@ module Steep
           {
             ImplicitBreakValueMismatch => :warning,
             FallbackAny => :information,
-            UnreachableBranch => :warning,
+            UnreachableValueBranch => :warning,
+            UnreachableBranch => :information,
             UnknownConstant => :warning,
             MethodDefinitionMissing => :information,
             FalseAssertion => :information,
@@ -989,6 +1016,7 @@ module Steep
             NoMethod => nil,
             ImplicitBreakValueMismatch => nil,
             FallbackAny => nil,
+            UnreachableValueBranch => nil,
             UnreachableBranch => nil,
             UnknownConstant => nil,
             MethodDefinitionMissing => nil,
@@ -1006,6 +1034,7 @@ module Steep
             NoMethod => nil,
             ImplicitBreakValueMismatch => nil,
             FallbackAny => nil,
+            UnreachableValueBranch => nil,
             UnreachableBranch => nil,
             UnknownConstant => nil,
             MethodDefinitionMissing => nil,

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

@@ -1883,9 +1883,25 @@ module Steep
 
             if truthy.unreachable
               if true_clause
+                _, _, _, loc = deconstruct_if_node!(node)
+
+                if loc.respond_to?(:keyword)
+                  condition_loc = loc #: NodeHelper::condition_loc
+                  case condition_loc.keyword.source
+                  when "if"
+                    location = condition_loc.begin || condition_loc.keyword
+                  when "unless"
+                    # `else` token always exists
+                    location = condition_loc.else || raise
+                  end
+                else
+                  location = true_clause.loc.expression
+                end
+
                 typing.add_error(
                   Diagnostic::Ruby::UnreachableBranch.new(
-                    node: true_clause || node
+                    node: true_clause,
+                    location: location || raise
                   )
                 )
               end
@@ -1893,9 +1909,25 @@ module Steep
 
             if falsy.unreachable
               if false_clause
+                _, _, _, loc = deconstruct_if_node!(node)
+
+                if loc.respond_to?(:keyword)
+                  condition_loc = loc #: NodeHelper::condition_loc
+                  case condition_loc.keyword.source
+                  when "if"
+                    # `else` token always exists
+                    location = condition_loc.else || raise
+                  when "unless"
+                    location = condition_loc.begin || condition_loc.keyword
+                  end
+                else
+                  location = false_clause.loc.expression
+                end
+
                 typing.add_error(
                   Diagnostic::Ruby::UnreachableBranch.new(
-                    node: false_clause || node
+                    node: false_clause,
+                    location: location || raise
                   )
                 )
               end
@@ -1918,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)
@@ -1961,19 +1989,25 @@ module Steep
                 next_branch_reachable &&= false_branch_reachable
                 body_constr = when_constr.update_type_env {|env| env.join(*test_envs) }
 
-                if body
-                  branch_results <<
+                branch_result =
+                  if body
                     body_constr
                       .for_branch(body)
                       .tap {|constr| typing.add_context_for_node(body, context: constr.context) }
                       .synthesize(body, hint: hint)
-                else
-                  branch_results << Pair.new(type: AST::Builtin.nil_type, constr: body_constr)
-                end
+                  else
+                    Pair.new(type: AST::Builtin.nil_type, constr: body_constr)
+                  end
 
-                unless branch_reachable
+                branch_results << branch_result
+
+                if !branch_reachable && !branch_result.type.is_a?(AST::Types::Bot)
                   typing.add_error(
-                    Diagnostic::Ruby::UnreachableBranch.new(node: body || clause)
+                    Diagnostic::Ruby::UnreachableValueBranch.new(
+                      node: clause,
+                      type: branch_result.type,
+                      location: clause.location.keyword
+                    )
                   )
                 end
 
@@ -2004,9 +2038,14 @@ module Steep
                 # `else` may present even if it's empty
                 if loc.else
                   if els
-                    typing.add_error Diagnostic::Ruby::UnreachableBranch.new(node: els)
-                  else
-                    typing.add_error Diagnostic::Ruby::UnreachableBranch.new(node: node, location: loc.else)
+                    else_result or raise
+                    unless else_result.type.is_a?(AST::Types::Bot)
+                      typing.add_error Diagnostic::Ruby::UnreachableValueBranch.new(
+                        node: els,
+                        type: else_result.type,
+                        location: node.loc.else || raise
+                      )
+                    end
                   end
                 end
               else
@@ -2042,21 +2081,29 @@ module Steep
                   branch_reachable ||= !truthy.unreachable
                 end
 
-                if body
-                  branch_results <<
+                branch_result =
+                  if body
                     when_clause_constr
                       .for_branch(body)
                       .update_type_env {|env| env.join(*body_envs) }
                       .tap {|constr| typing.add_context_for_node(body, context: constr.context) }
                       .synthesize(body, hint: hint)
-                else
-                  branch_results << Pair.new(type: AST::Builtin.nil_type, constr: when_clause_constr)
-                end
+                  else
+                    Pair.new(type: AST::Builtin.nil_type, constr: when_clause_constr)
+                  end
+
+                branch_results << branch_result
 
                 unless branch_reachable
-                  typing.add_error(
-                    Diagnostic::Ruby::UnreachableBranch.new(node: body || when_clause)
-                  )
+                  unless branch_result.type.is_a?(AST::Types::Bot)
+                    typing.add_error(
+                      Diagnostic::Ruby::UnreachableValueBranch.new(
+                        node: when_clause,
+                        type: branch_result.type,
+                        location: when_clause.location.keyword || raise
+                      )
+                    )
+                  end
                 end
               end
 
@@ -2570,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)
@@ -2584,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)
 
@@ -3026,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) }
@@ -3913,13 +3992,15 @@ module Steep
             end
 
             if hint && !fvs.empty?
-              if check_relation(sub_type: method_type.type.return_type, super_type: hint, constraints: constraints).success?
-                method_type, solved, s = apply_solution(errors, node: node, method_type: method_type) do
-                  constraints.solution(checker, variables: fvs, context: ccontext)
+              if hint.free_variables.subset?(self_type.free_variables)
+                if check_relation(sub_type: method_type.type.return_type, super_type: hint, constraints: constraints).success?
+                  method_type, solved, s = apply_solution(errors, node: node, method_type: method_type) do
+                    constraints.solution(checker, variables: fvs, context: ccontext)
+                  end
                 end
-              end
 
-              method_type.block or raise
+                method_type.block or raise
+              end
             end
 
             # Method accepts block

data/lib/steep/type_inference/context.rb

@@ -126,7 +126,9 @@ module Steep
 
         def upper_bounds
           table.each_value.with_object({}) do |type_param, bounds|
-            bounds[type_param.name] = type_param.upper_bound
+            if type_param.upper_bound
+              bounds[type_param.name] = type_param.upper_bound
+            end
           end
         end
 

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.4"
+  VERSION = "1.5.0.pre.6"
 end

data/sig/shims/parser/nodes.rbs

@@ -62,6 +62,11 @@ module Parser
       %a{pure} def end: () -> Source::Range?
     end
 
+    # ```ruby
+    # foo ? bar : baz
+    # #   ^               question
+    # #         ^         colon
+    # ```
     interface _Ternary
       %a{pure} def question: () -> Source::Range
 

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

@@ -479,6 +479,31 @@ module Steep
         def header_line: () -> String
       end
 
+      # The branch is unreachable, but not `bot` type
+      #
+      # We often have `else` branch to make the code more defensive:
+      #
+      # ```ruby
+      # case value
+      # when Integer
+      #   # ...
+      # when String
+      #   # ...
+      # else
+      #   raise "Cannot happen!"
+      # end
+      # ```
+      #
+      # 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
+
+        def initialize: (node: Parser::AST::Node, type: AST::Types::t, ?location: location) -> void
+
+        def header_line: () -> String
+      end
+
       class UnexpectedSplat < Base
         attr_reader type: untyped
 
@@ -597,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

data/smoke/diagnostics/test_expectations.yml

@@ -120,18 +120,6 @@
     message: 'The method parameter has different kind from the declaration `(name:
       ::String, size: ::Integer) -> void`'
     code: Ruby::DifferentMethodParameterKind
-- file: else_on_exhaustive_case.rb
-  diagnostics:
-  - range:
-      start:
-        line: 11
-        character: 2
-      end:
-        line: 11
-        character: 26
-    severity: ERROR
-    message: The branch is unreachable
-    code: Ruby::UnreachableBranch
 - file: incompatible_annotation.rb
   diagnostics:
   - range:

data/smoke/type_case/test_expectations.yml

@@ -13,14 +13,14 @@
     code: Ruby::NoMethod
   - range:
       start:
-        line: 12
-        character: 2
+        line: 11
+        character: 0
       end:
-        line: 12
-        character: 10
+        line: 11
+        character: 4
     severity: ERROR
-    message: The branch is unreachable
-    code: Ruby::UnreachableBranch
+    message: The branch may evaluate to a value of `untyped` but unreachable
+    code: Ruby::UnreachableValueBranch
   - range:
       start:
         line: 12

metadata

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