ruby-lsp 0.17.8 → 0.17.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e3a8a120b4cf3045cdeec98d2fb417ffdd300947b6426788d827346c43812ffc
-  data.tar.gz: b43a823e71fca99a9cf79b3a6ce19e7a0ec86e499b943aecae1666788859d055
+  metadata.gz: f3deccbc9952a61d46392be2f050a4684b108e7cd3da0085a4e8997168dfc021
+  data.tar.gz: d1b9a804d9e67aa2d23b39f12c79c6e1d5ba940ec360170623f7e0870e7d6c78
 SHA512:
-  metadata.gz: 9662d88d3f37b4fd7b744a69f38f2a20cd4bf00291f63968578e50bef3400916870efdcf58b6e81dd78a6829c4f8a7dd174e6d212ddc3a265420b29eaa2b6d8a
-  data.tar.gz: b788ef9185e02a732cd2dccef6273d8dd3fb471ebb8c2300b3ac78cc48d3952eee378a777cc4cf4ceb927590fff7bcdfc57c95f0924b21e589eb850ec9128641
+  metadata.gz: fe2e99145d0f268644a5d8feeff49146e635998ab8ff3eff18f47b1f555bb249b296966d0a431c930ab6ebca58032ed954a338f7c075300869545711bcfae50e
+  data.tar.gz: 36f253a202755a49e33b8d6c4906aa0acfebe9fe52772519684d433649d7fbadfee186274eba94027017535e55438333759477e2dbb87a7da7e9ead0bc98aaa7

data/VERSION

@@ -1 +1 @@
-0.17.8
+0.17.9

data/lib/ruby_indexer/lib/ruby_indexer/index.rb

@@ -84,6 +84,34 @@ module RubyIndexer
       @require_paths_tree.search(query)
     end
 
+    # Searches for a constant based on an unqualified name and returns the first possible match regardless of whether
+    # there are more possible matching entries
+    sig do
+      params(
+        name: String,
+      ).returns(T.nilable(T::Array[T.any(
+        Entry::Namespace,
+        Entry::Alias,
+        Entry::UnresolvedAlias,
+        Entry::Constant,
+      )]))
+    end
+    def first_unqualified_const(name)
+      _name, entries = @entries.find do |const_name, _entries|
+        const_name.end_with?(name)
+      end
+
+      T.cast(
+        entries,
+        T.nilable(T::Array[T.any(
+          Entry::Namespace,
+          Entry::Alias,
+          Entry::UnresolvedAlias,
+          Entry::Constant,
+        )]),
+      )
+    end
+
     # Searches entries in the index based on an exact prefix, intended for providing autocomplete. All possible matches
     # to the prefix are returned. The return is an array of arrays, where each entry is the array of entries for a given
     # name match. For example:

data/lib/ruby_indexer/lib/ruby_indexer/rbs_indexer.rb

@@ -37,45 +37,33 @@ module RubyIndexer
     sig { params(declaration: RBS::AST::Declarations::Base, pathname: Pathname).void }
     def process_declaration(declaration, pathname)
       case declaration
-      when RBS::AST::Declarations::Class
-        handle_class_declaration(declaration, pathname)
-      when RBS::AST::Declarations::Module
-        handle_module_declaration(declaration, pathname)
+      when RBS::AST::Declarations::Class, RBS::AST::Declarations::Module
+        handle_class_or_module_declaration(declaration, pathname)
       else # rubocop:disable Style/EmptyElse
         # Other kinds not yet handled
       end
     end
 
-    sig { params(declaration: RBS::AST::Declarations::Class, pathname: Pathname).void }
-    def handle_class_declaration(declaration, pathname)
-      nesting = [declaration.name.name.to_s]
-      file_path = pathname.to_s
-      location = to_ruby_indexer_location(declaration.location)
-      comments = Array(declaration.comment&.string)
-      parent_class = declaration.super_class&.name&.name&.to_s
-      class_entry = Entry::Class.new(nesting, file_path, location, location, comments, parent_class)
-      add_declaration_mixins_to_entry(declaration, class_entry)
-      @index.add(class_entry)
-      declaration.members.each do |member|
-        next unless member.is_a?(RBS::AST::Members::MethodDefinition)
-
-        handle_method(member, class_entry)
-      end
+    sig do
+      params(declaration: T.any(RBS::AST::Declarations::Class, RBS::AST::Declarations::Module), pathname: Pathname).void
     end
-
-    sig { params(declaration: RBS::AST::Declarations::Module, pathname: Pathname).void }
-    def handle_module_declaration(declaration, pathname)
+    def handle_class_or_module_declaration(declaration, pathname)
       nesting = [declaration.name.name.to_s]
       file_path = pathname.to_s
       location = to_ruby_indexer_location(declaration.location)
       comments = Array(declaration.comment&.string)
-      module_entry = Entry::Module.new(nesting, file_path, location, location, comments)
-      add_declaration_mixins_to_entry(declaration, module_entry)
-      @index.add(module_entry)
+      entry = if declaration.is_a?(RBS::AST::Declarations::Class)
+        parent_class = declaration.super_class&.name&.name&.to_s
+        Entry::Class.new(nesting, file_path, location, location, comments, parent_class)
+      else
+        Entry::Module.new(nesting, file_path, location, location, comments)
+      end
+      add_declaration_mixins_to_entry(declaration, entry)
+      @index.add(entry)
       declaration.members.each do |member|
         next unless member.is_a?(RBS::AST::Members::MethodDefinition)
 
-        handle_method(member, module_entry)
+        handle_method(member, entry)
       end
     end
 

data/lib/ruby_indexer/test/index_test.rb

@@ -1542,6 +1542,21 @@ module RubyIndexer
       assert_empty(@index.method_completion_candidates("bar", "Foo"))
     end
 
+    def test_first_unqualified_const
+      index(<<~RUBY)
+        module Foo
+          class Bar; end
+        end
+
+        module Baz
+          class Bar; end
+        end
+      RUBY
+
+      entry = T.must(@index.first_unqualified_const("Bar")&.first)
+      assert_equal("Foo::Bar", entry.name)
+    end
+
     def test_completion_does_not_duplicate_overridden_methods
       index(<<~RUBY)
         class Foo

data/lib/ruby_lsp/document.rb

@@ -10,6 +10,16 @@ module RubyLsp
       end
     end
 
+    class SorbetLevel < T::Enum
+      enums do
+        None = new("none")
+        Ignore = new("ignore")
+        False = new("false")
+        True = new("true")
+        Strict = new("strict")
+      end
+    end
+
     extend T::Sig
     extend T::Helpers
 
@@ -213,10 +223,23 @@ module RubyLsp
       NodeContext.new(closest, parent, nesting_nodes, call_node)
     end
 
-    sig { returns(T::Boolean) }
-    def sorbet_sigil_is_true_or_higher
-      parse_result.magic_comments.any? do |comment|
-        comment.key == "typed" && ["true", "strict", "strong"].include?(comment.value)
+    sig { returns(SorbetLevel) }
+    def sorbet_level
+      sigil = parse_result.magic_comments.find do |comment|
+        comment.key == "typed"
+      end&.value
+
+      case sigil
+      when "ignore"
+        SorbetLevel::Ignore
+      when "false"
+        SorbetLevel::False
+      when "true"
+        SorbetLevel::True
+      when "strict", "strong"
+        SorbetLevel::Strict
+      else
+        SorbetLevel::None
       end
     end
 

data/lib/ruby_lsp/global_state.rb

@@ -36,10 +36,10 @@ module RubyLsp
       @test_library = T.let("minitest", String)
       @has_type_checker = T.let(true, T::Boolean)
       @index = T.let(RubyIndexer::Index.new, RubyIndexer::Index)
-      @type_inferrer = T.let(TypeInferrer.new(@index), TypeInferrer)
       @supported_formatters = T.let({}, T::Hash[String, Requests::Support::Formatter])
       @supports_watching_files = T.let(false, T::Boolean)
       @experimental_features = T.let(false, T::Boolean)
+      @type_inferrer = T.let(TypeInferrer.new(@index, @experimental_features), TypeInferrer)
     end
 
     sig { params(identifier: String, instance: Requests::Support::Formatter).void }
@@ -90,6 +90,7 @@ module RubyLsp
       end
 
       @experimental_features = options.dig(:initializationOptions, :experimentalFeaturesEnabled) || false
+      @type_inferrer.experimental_features = @experimental_features
     end
 
     sig { returns(String) }

data/lib/ruby_lsp/listeners/completion.rb

@@ -56,7 +56,7 @@ module RubyLsp
           response_builder: ResponseBuilders::CollectionResponseBuilder[Interface::CompletionItem],
           global_state: GlobalState,
           node_context: NodeContext,
-          typechecker_enabled: T::Boolean,
+          sorbet_level: Document::SorbetLevel,
           dispatcher: Prism::Dispatcher,
           uri: URI::Generic,
           trigger_character: T.nilable(String),
@@ -66,7 +66,7 @@ module RubyLsp
         response_builder,
         global_state,
         node_context,
-        typechecker_enabled,
+        sorbet_level,
         dispatcher,
         uri,
         trigger_character
@@ -76,7 +76,7 @@ module RubyLsp
         @index = T.let(global_state.index, RubyIndexer::Index)
         @type_inferrer = T.let(global_state.type_inferrer, TypeInferrer)
         @node_context = node_context
-        @typechecker_enabled = typechecker_enabled
+        @sorbet_level = sorbet_level
         @uri = uri
         @trigger_character = trigger_character
 
@@ -97,7 +97,9 @@ module RubyLsp
       # Handle completion on regular constant references (e.g. `Bar`)
       sig { params(node: Prism::ConstantReadNode).void }
       def on_constant_read_node_enter(node)
-        return if @global_state.has_type_checker
+        # The only scenario where Sorbet doesn't provide constant completion is on ignored files. Even if the file has
+        # no sigil, Sorbet will still provide completion for constants
+        return if @sorbet_level != Document::SorbetLevel::Ignore
 
         name = constant_name(node)
         return if name.nil?
@@ -118,7 +120,9 @@ module RubyLsp
       # Handle completion on namespaced constant references (e.g. `Foo::Bar`)
       sig { params(node: Prism::ConstantPathNode).void }
       def on_constant_path_node_enter(node)
-        return if @global_state.has_type_checker
+        # The only scenario where Sorbet doesn't provide constant completion is on ignored files. Even if the file has
+        # no sigil, Sorbet will still provide completion for constants
+        return if @sorbet_level != Document::SorbetLevel::Ignore
 
         name = constant_name(node)
         return if name.nil?
@@ -128,28 +132,32 @@ module RubyLsp
 
       sig { params(node: Prism::CallNode).void }
       def on_call_node_enter(node)
-        receiver = node.receiver
-
-        # When writing `Foo::`, the AST assigns a method call node (because you can use that syntax to invoke singleton
-        # methods). However, in addition to providing method completion, we also need to show possible constant
-        # completions
-        if (receiver.is_a?(Prism::ConstantReadNode) || receiver.is_a?(Prism::ConstantPathNode)) &&
-            node.call_operator == "::"
-
-          name = constant_name(receiver)
-
-          if name
-            start_loc = node.location
-            end_loc = T.must(node.call_operator_loc)
-
-            constant_path_completion(
-              "#{name}::",
-              Interface::Range.new(
-                start: Interface::Position.new(line: start_loc.start_line - 1, character: start_loc.start_column),
-                end: Interface::Position.new(line: end_loc.end_line - 1, character: end_loc.end_column),
-              ),
-            )
-            return
+        # The only scenario where Sorbet doesn't provide constant completion is on ignored files. Even if the file has
+        # no sigil, Sorbet will still provide completion for constants
+        if @sorbet_level == Document::SorbetLevel::Ignore
+          receiver = node.receiver
+
+          # When writing `Foo::`, the AST assigns a method call node (because you can use that syntax to invoke
+          # singleton methods). However, in addition to providing method completion, we also need to show possible
+          # constant completions
+          if (receiver.is_a?(Prism::ConstantReadNode) || receiver.is_a?(Prism::ConstantPathNode)) &&
+              node.call_operator == "::"
+
+            name = constant_name(receiver)
+
+            if name
+              start_loc = node.location
+              end_loc = T.must(node.call_operator_loc)
+
+              constant_path_completion(
+                "#{name}::",
+                Interface::Range.new(
+                  start: Interface::Position.new(line: start_loc.start_line - 1, character: start_loc.start_column),
+                  end: Interface::Position.new(line: end_loc.end_line - 1, character: end_loc.end_column),
+                ),
+              )
+              return
+            end
           end
         end
 
@@ -162,7 +170,7 @@ module RubyLsp
         when "require_relative"
           complete_require_relative(node)
         else
-          complete_methods(node, name) unless @typechecker_enabled
+          complete_methods(node, name)
         end
       end
 
@@ -247,10 +255,14 @@ module RubyLsp
 
       sig { params(name: String, location: Prism::Location).void }
       def handle_instance_variable_completion(name, location)
+        # Sorbet enforces that all instance variables be declared on typed strict or higher, which means it will be able
+        # to provide all features for them
+        return if @sorbet_level == Document::SorbetLevel::Strict
+
         type = @type_inferrer.infer_receiver_type(@node_context)
         return unless type
 
-        @index.instance_variable_completion_candidates(name, type).each do |entry|
+        @index.instance_variable_completion_candidates(name, type.name).each do |entry|
           variable_name = entry.name
 
           label_details = Interface::CompletionItemLabelDetails.new(
@@ -321,12 +333,16 @@ module RubyLsp
 
       sig { params(node: Prism::CallNode, name: String).void }
       def complete_methods(node, name)
-        # If the node has a receiver, then we don't need to provide local nor keyword completions
-        if !@global_state.has_type_checker && !node.receiver
+        # If the node has a receiver, then we don't need to provide local nor keyword completions. Sorbet can provide
+        # local and keyword completion for any file with a Sorbet level of true or higher
+        if !sorbet_level_true_or_higher?(@sorbet_level) && !node.receiver
           add_local_completions(node, name)
           add_keyword_completions(node, name)
         end
 
+        # Sorbet can provide completion for methods invoked on self on typed true or higher files
+        return if sorbet_level_true_or_higher?(@sorbet_level) && self_receiver?(node)
+
         type = @type_inferrer.infer_receiver_type(@node_context)
         return unless type
 
@@ -350,8 +366,11 @@ module RubyLsp
 
         return unless range
 
-        @index.method_completion_candidates(method_name, type).each do |entry|
+        guessed_type = type.name
+
+        @index.method_completion_candidates(method_name, type.name).each do |entry|
           entry_name = entry.name
+          owner_name = entry.owner&.name
 
           label_details = Interface::CompletionItemLabelDetails.new(
             description: entry.file_name,
@@ -364,7 +383,8 @@ module RubyLsp
             text_edit: Interface::TextEdit.new(range: range, new_text: entry_name),
             kind: Constant::CompletionItemKind::METHOD,
             data: {
-              owner_name: entry.owner&.name,
+              owner_name: owner_name,
+              guessed_type: guessed_type,
             },
           )
         end

data/lib/ruby_lsp/listeners/definition.rb

@@ -20,10 +20,10 @@ module RubyLsp
           uri: URI::Generic,
           node_context: NodeContext,
           dispatcher: Prism::Dispatcher,
-          typechecker_enabled: T::Boolean,
+          sorbet_level: Document::SorbetLevel,
         ).void
       end
-      def initialize(response_builder, global_state, language_id, uri, node_context, dispatcher, typechecker_enabled) # rubocop:disable Metrics/ParameterLists
+      def initialize(response_builder, global_state, language_id, uri, node_context, dispatcher, sorbet_level) # rubocop:disable Metrics/ParameterLists
         @response_builder = response_builder
         @global_state = global_state
         @index = T.let(global_state.index, RubyIndexer::Index)
@@ -31,7 +31,7 @@ module RubyLsp
         @language_id = language_id
         @uri = uri
         @node_context = node_context
-        @typechecker_enabled = typechecker_enabled
+        @sorbet_level = sorbet_level
 
         dispatcher.register(
           self,
@@ -53,6 +53,11 @@ module RubyLsp
 
       sig { params(node: Prism::CallNode).void }
       def on_call_node_enter(node)
+        # Sorbet can handle go to definition for methods invoked on self on typed true or higher
+        if (@sorbet_level == Document::SorbetLevel::True || @sorbet_level == Document::SorbetLevel::Strict) &&
+            self_receiver?(node)
+        end
+
         message = node.message
         return unless message
 
@@ -60,7 +65,7 @@ module RubyLsp
 
         # Until we can properly infer the receiver type in erb files (maybe with ruby-lsp-rails),
         # treating method calls' type as `nil` will allow users to get some completion support first
-        if @language_id == Document::LanguageId::ERB && inferrer_receiver_type == "Object"
+        if @language_id == Document::LanguageId::ERB && inferrer_receiver_type&.name == "Object"
           inferrer_receiver_type = nil
         end
 
@@ -149,6 +154,9 @@ module RubyLsp
 
       sig { void }
       def handle_super_node_definition
+        # Sorbet can handle super hover on typed true or higher
+        return if sorbet_level_true_or_higher?(@sorbet_level)
+
         surrounding_method = @node_context.surrounding_method
         return unless surrounding_method
 
@@ -161,10 +169,14 @@ module RubyLsp
 
       sig { params(name: String).void }
       def handle_instance_variable_definition(name)
+        # Sorbet enforces that all instance variables be declared on typed strict or higher, which means it will be able
+        # to provide all features for them
+        return if @sorbet_level == Document::SorbetLevel::Strict
+
         type = @type_inferrer.infer_receiver_type(@node_context)
         return unless type
 
-        entries = @index.resolve_instance_variable(name, type)
+        entries = @index.resolve_instance_variable(name, type.name)
         return unless entries
 
         entries.each do |entry|
@@ -182,10 +194,10 @@ module RubyLsp
         # If by any chance we haven't indexed the owner, then there's no way to find the right declaration
       end
 
-      sig { params(message: String, receiver_type: T.nilable(String), inherited_only: T::Boolean).void }
+      sig { params(message: String, receiver_type: T.nilable(TypeInferrer::Type), inherited_only: T::Boolean).void }
       def handle_method_definition(message, receiver_type, inherited_only: false)
         methods = if receiver_type
-          @index.resolve_method(message, receiver_type, inherited_only: inherited_only)
+          @index.resolve_method(message, receiver_type.name, inherited_only: inherited_only)
         else
           # If the method doesn't have a receiver, then we provide a few candidates to jump to
           # But we don't want to provide too many candidates, as it can be overwhelming
@@ -196,7 +208,7 @@ module RubyLsp
 
         methods.each do |target_method|
           file_path = target_method.file_path
-          next if @typechecker_enabled && not_in_dependencies?(file_path)
+          next if sorbet_level_true_or_higher?(@sorbet_level) && not_in_dependencies?(file_path)
 
           @response_builder << Interface::LocationLink.new(
             target_uri: URI::Generic.from_path(path: file_path).to_s,
@@ -253,10 +265,10 @@ module RubyLsp
 
         entries.each do |entry|
           # If the project has Sorbet, then we only want to handle go to definition for constants defined in gems, as an
-          # additional behavior on top of jumping to RBIs. Sorbet can already handle go to definition for all constants
-          # in the project, even if the files are typed false
+          # additional behavior on top of jumping to RBIs. The only sigil where Sorbet cannot handle constants is typed
+          # ignore
           file_path = entry.file_path
-          next if @typechecker_enabled && not_in_dependencies?(file_path)
+          next if @sorbet_level != Document::SorbetLevel::Ignore && not_in_dependencies?(file_path)
 
           @response_builder << Interface::LocationLink.new(
             target_uri: URI::Generic.from_path(path: file_path).to_s,

data/lib/ruby_lsp/listeners/hover.rb

@@ -42,17 +42,17 @@ module RubyLsp
           uri: URI::Generic,
           node_context: NodeContext,
           dispatcher: Prism::Dispatcher,
-          typechecker_enabled: T::Boolean,
+          sorbet_level: Document::SorbetLevel,
         ).void
       end
-      def initialize(response_builder, global_state, uri, node_context, dispatcher, typechecker_enabled) # rubocop:disable Metrics/ParameterLists
+      def initialize(response_builder, global_state, uri, node_context, dispatcher, sorbet_level) # rubocop:disable Metrics/ParameterLists
         @response_builder = response_builder
         @global_state = global_state
         @index = T.let(global_state.index, RubyIndexer::Index)
         @type_inferrer = T.let(global_state.type_inferrer, TypeInferrer)
         @path = T.let(uri.to_standardized_path, T.nilable(String))
         @node_context = node_context
-        @typechecker_enabled = typechecker_enabled
+        @sorbet_level = sorbet_level
 
         dispatcher.register(
           self,
@@ -73,7 +73,7 @@ module RubyLsp
 
       sig { params(node: Prism::ConstantReadNode).void }
       def on_constant_read_node_enter(node)
-        return if @typechecker_enabled
+        return if @sorbet_level != Document::SorbetLevel::Ignore
 
         name = constant_name(node)
         return if name.nil?
@@ -83,14 +83,14 @@ module RubyLsp
 
       sig { params(node: Prism::ConstantWriteNode).void }
       def on_constant_write_node_enter(node)
-        return if @global_state.has_type_checker
+        return if @sorbet_level != Document::SorbetLevel::Ignore
 
         generate_hover(node.name.to_s, node.name_loc)
       end
 
       sig { params(node: Prism::ConstantPathNode).void }
       def on_constant_path_node_enter(node)
-        return if @global_state.has_type_checker
+        return if @sorbet_level != Document::SorbetLevel::Ignore
 
         name = constant_name(node)
         return if name.nil?
@@ -105,7 +105,7 @@ module RubyLsp
           return
         end
 
-        return if @typechecker_enabled
+        return if sorbet_level_true_or_higher?(@sorbet_level) && self_receiver?(node)
 
         message = node.message
         return unless message
@@ -157,6 +157,9 @@ module RubyLsp
 
       sig { void }
       def handle_super_node_hover
+        # Sorbet can handle super hover on typed true or higher
+        return if sorbet_level_true_or_higher?(@sorbet_level)
+
         surrounding_method = @node_context.surrounding_method
         return unless surrounding_method
 
@@ -168,11 +171,16 @@ module RubyLsp
         type = @type_inferrer.infer_receiver_type(@node_context)
         return unless type
 
-        methods = @index.resolve_method(message, type, inherited_only: inherited_only)
+        methods = @index.resolve_method(message, type.name, inherited_only: inherited_only)
         return unless methods
 
         title = "#{message}#{T.must(methods.first).decorated_parameters}"
 
+        if type.is_a?(TypeInferrer::GuessedType)
+          title << "\n\nGuessed receiver: #{type.name}"
+          @response_builder.push("[Learn more about guessed types](#{GUESSED_TYPES_URL})\n", category: :links)
+        end
+
         categorized_markdown_from_index_entries(title, methods).each do |category, content|
           @response_builder.push(content, category: category)
         end
@@ -180,10 +188,14 @@ module RubyLsp
 
       sig { params(name: String).void }
       def handle_instance_variable_hover(name)
+        # Sorbet enforces that all instance variables be declared on typed strict or higher, which means it will be able
+        # to provide all features for them
+        return if @sorbet_level == Document::SorbetLevel::Strict
+
         type = @type_inferrer.infer_receiver_type(@node_context)
         return unless type
 
-        entries = @index.resolve_instance_variable(name, type)
+        entries = @index.resolve_instance_variable(name, type.name)
         return unless entries
 
         categorized_markdown_from_index_entries(name, entries).each do |category, content|

data/lib/ruby_lsp/listeners/signature_help.rb

@@ -13,11 +13,11 @@ module RubyLsp
           global_state: GlobalState,
           node_context: NodeContext,
           dispatcher: Prism::Dispatcher,
-          typechecker_enabled: T::Boolean,
+          sorbet_level: Document::SorbetLevel,
         ).void
       end
-      def initialize(response_builder, global_state, node_context, dispatcher, typechecker_enabled)
-        @typechecker_enabled = typechecker_enabled
+      def initialize(response_builder, global_state, node_context, dispatcher, sorbet_level)
+        @sorbet_level = sorbet_level
         @response_builder = response_builder
         @global_state = global_state
         @index = T.let(global_state.index, RubyIndexer::Index)
@@ -28,7 +28,7 @@ module RubyLsp
 
       sig { params(node: Prism::CallNode).void }
       def on_call_node_enter(node)
-        return if @typechecker_enabled
+        return if sorbet_level_true_or_higher?(@sorbet_level)
 
         message = node.message
         return unless message
@@ -36,7 +36,7 @@ module RubyLsp
         type = @type_inferrer.infer_receiver_type(@node_context)
         return unless type
 
-        methods = @index.resolve_method(message, type)
+        methods = @index.resolve_method(message, type.name)
         return unless methods
 
         target_method = methods.first
@@ -61,6 +61,13 @@ module RubyLsp
           active_parameter += 1
         end
 
+        title = +""
+
+        extra_links = if type.is_a?(TypeInferrer::GuessedType)
+          title << "\n\nGuessed receiver: #{type.name}"
+          "[Learn more about guessed types](#{GUESSED_TYPES_URL})"
+        end
+
         signature_help = Interface::SignatureHelp.new(
           signatures: [
             Interface::SignatureInformation.new(
@@ -68,7 +75,7 @@ module RubyLsp
               parameters: parameters.map { |param| Interface::ParameterInformation.new(label: param.name) },
               documentation: Interface::MarkupContent.new(
                 kind: "markdown",
-                value: markdown_from_index_entries("", methods),
+                value: markdown_from_index_entries(title, methods, extra_links: extra_links),
               ),
             ),
           ],

data/lib/ruby_lsp/requests/completion.rb

@@ -49,11 +49,11 @@ module RubyLsp
           document: Document,
           global_state: GlobalState,
           params: T::Hash[Symbol, T.untyped],
-          typechecker_enabled: T::Boolean,
+          sorbet_level: Document::SorbetLevel,
           dispatcher: Prism::Dispatcher,
         ).void
       end
-      def initialize(document, global_state, params, typechecker_enabled, dispatcher)
+      def initialize(document, global_state, params, sorbet_level, dispatcher)
         super()
         @target = T.let(nil, T.nilable(Prism::Node))
         @dispatcher = dispatcher
@@ -84,7 +84,7 @@ module RubyLsp
           @response_builder,
           global_state,
           node_context,
-          typechecker_enabled,
+          sorbet_level,
           dispatcher,
           document.uri,
           params.dig(:context, :triggerCharacter),

data/lib/ruby_lsp/requests/completion_resolve.rb

@@ -47,7 +47,7 @@ module RubyLsp
         #
         # For example, forgetting to return the `insertText` included in the original item will make the editor use the
         # `label` for the text edit instead
-        label = @item[:label]
+        label = @item[:label].dup
         entries = @index[label] || []
 
         owner_name = @item.dig(:data, :owner_name)
@@ -62,12 +62,19 @@ module RubyLsp
         first_entry = T.must(entries.first)
 
         if first_entry.is_a?(RubyIndexer::Entry::Member)
-          label = "#{label}#{first_entry.decorated_parameters}"
+          label = +"#{label}#{first_entry.decorated_parameters}"
+        end
+
+        guessed_type = @item.dig(:data, :guessed_type)
+
+        extra_links = if guessed_type
+          label << "\n\nGuessed receiver: #{guessed_type}"
+          "[Learn more about guessed types](#{GUESSED_TYPES_URL})"
         end
 
         @item[:documentation] = Interface::MarkupContent.new(
           kind: "markdown",
-          value: markdown_from_index_entries(label, entries, MAX_DOCUMENTATION_ENTRIES),
+          value: markdown_from_index_entries(label, entries, MAX_DOCUMENTATION_ENTRIES, extra_links: extra_links),
         )
 
         @item

data/lib/ruby_lsp/requests/definition.rb

@@ -36,10 +36,10 @@ module RubyLsp
           global_state: GlobalState,
           position: T::Hash[Symbol, T.untyped],
           dispatcher: Prism::Dispatcher,
-          typechecker_enabled: T::Boolean,
+          sorbet_level: Document::SorbetLevel,
         ).void
       end
-      def initialize(document, global_state, position, dispatcher, typechecker_enabled)
+      def initialize(document, global_state, position, dispatcher, sorbet_level)
         super()
         @response_builder = T.let(
           ResponseBuilders::CollectionResponseBuilder[T.any(Interface::Location, Interface::LocationLink)].new,
@@ -96,7 +96,7 @@ module RubyLsp
             document.uri,
             node_context,
             dispatcher,
-            typechecker_enabled,
+            sorbet_level,
           )
 
           Addon.addons.each do |addon|

data/lib/ruby_lsp/requests/hover.rb

@@ -36,10 +36,10 @@ module RubyLsp
           global_state: GlobalState,
           position: T::Hash[Symbol, T.untyped],
           dispatcher: Prism::Dispatcher,
-          typechecker_enabled: T::Boolean,
+          sorbet_level: Document::SorbetLevel,
         ).void
       end
-      def initialize(document, global_state, position, dispatcher, typechecker_enabled)
+      def initialize(document, global_state, position, dispatcher, sorbet_level)
         super()
         node_context = document.locate_node(position, node_types: Listeners::Hover::ALLOWED_TARGETS)
         target = node_context.node
@@ -65,7 +65,7 @@ module RubyLsp
         @target = T.let(target, T.nilable(Prism::Node))
         uri = document.uri
         @response_builder = T.let(ResponseBuilders::Hover.new, ResponseBuilders::Hover)
-        Listeners::Hover.new(@response_builder, global_state, uri, node_context, dispatcher, typechecker_enabled)
+        Listeners::Hover.new(@response_builder, global_state, uri, node_context, dispatcher, sorbet_level)
         Addon.addons.each do |addon|
           addon.create_hover_listener(@response_builder, node_context, dispatcher)
         end

data/lib/ruby_lsp/requests/signature_help.rb

@@ -46,10 +46,10 @@ module RubyLsp
           position: T::Hash[Symbol, T.untyped],
           context: T.nilable(T::Hash[Symbol, T.untyped]),
           dispatcher: Prism::Dispatcher,
-          typechecker_enabled: T::Boolean,
+          sorbet_level: Document::SorbetLevel,
         ).void
       end
-      def initialize(document, global_state, position, context, dispatcher, typechecker_enabled) # rubocop:disable Metrics/ParameterLists
+      def initialize(document, global_state, position, context, dispatcher, sorbet_level) # rubocop:disable Metrics/ParameterLists
         super()
         node_context = document.locate_node(
           { line: position[:line], character: position[:character] },
@@ -61,7 +61,7 @@ module RubyLsp
         @target = T.let(target, T.nilable(Prism::Node))
         @dispatcher = dispatcher
         @response_builder = T.let(ResponseBuilders::SignatureHelp.new, ResponseBuilders::SignatureHelp)
-        Listeners::SignatureHelp.new(@response_builder, global_state, node_context, dispatcher, typechecker_enabled)
+        Listeners::SignatureHelp.new(@response_builder, global_state, node_context, dispatcher, sorbet_level)
       end
 
       sig { override.returns(T.nilable(Interface::SignatureHelp)) }

data/lib/ruby_lsp/requests/support/common.rb

@@ -130,13 +130,17 @@ module RubyLsp
             title: String,
             entries: T.any(T::Array[RubyIndexer::Entry], RubyIndexer::Entry),
             max_entries: T.nilable(Integer),
+            extra_links: T.nilable(String),
           ).returns(String)
         end
-        def markdown_from_index_entries(title, entries, max_entries = nil)
+        def markdown_from_index_entries(title, entries, max_entries = nil, extra_links: nil)
           categorized_markdown = categorized_markdown_from_index_entries(title, entries, max_entries)
 
+          markdown = +(categorized_markdown[:title] || "")
+          markdown << "\n\n#{extra_links}" if extra_links
+
           <<~MARKDOWN.chomp
-            #{categorized_markdown[:title]}
+            #{markdown}
 
             #{categorized_markdown[:links]}
 
@@ -204,6 +208,11 @@ module RubyLsp
             Constant::SymbolKind::FIELD
           end
         end
+
+        sig { params(sorbet_level: Document::SorbetLevel).returns(T::Boolean) }
+        def sorbet_level_true_or_higher?(sorbet_level)
+          sorbet_level == Document::SorbetLevel::True || sorbet_level == Document::SorbetLevel::Strict
+        end
       end
     end
   end

data/lib/ruby_lsp/server.rb

@@ -477,15 +477,17 @@ module RubyLsp
             @global_state,
             params[:position],
             dispatcher,
-            typechecker_enabled?(document),
+            sorbet_level(document),
           ).perform,
         ),
       )
     end
 
-    sig { params(document: Document).returns(T::Boolean) }
-    def typechecker_enabled?(document)
-      @global_state.has_type_checker && document.sorbet_sigil_is_true_or_higher
+    sig { params(document: Document).returns(Document::SorbetLevel) }
+    def sorbet_level(document)
+      return Document::SorbetLevel::Ignore unless @global_state.has_type_checker
+
+      document.sorbet_level
     end
 
     sig { params(message: T::Hash[Symbol, T.untyped]).void }
@@ -594,7 +596,7 @@ module RubyLsp
             document,
             @global_state,
             params,
-            typechecker_enabled?(document),
+            sorbet_level(document),
             dispatcher,
           ).perform,
         ),
@@ -624,7 +626,7 @@ module RubyLsp
             params[:position],
             params[:context],
             dispatcher,
-            typechecker_enabled?(document),
+            sorbet_level(document),
           ).perform,
         ),
       )
@@ -644,7 +646,7 @@ module RubyLsp
             @global_state,
             params[:position],
             dispatcher,
-            typechecker_enabled?(document),
+            sorbet_level(document),
           ).perform,
         ),
       )

data/lib/ruby_lsp/store.rb

@@ -38,13 +38,18 @@ module RubyLsp
       document = @state[uri.to_s]
       return document unless document.nil?
 
-      path = T.must(uri.to_standardized_path)
+      # For unsaved files (`untitled:Untitled-1` uris), there's no path to read from. If we don't have the untitled file
+      # already present in the store, then we have to raise non existing document error
+      path = uri.to_standardized_path
+      raise NonExistingDocumentError, uri.to_s unless path
+
       ext = File.extname(path)
       language_id = if ext == ".erb" || ext == ".rhtml"
         Document::LanguageId::ERB
       else
         Document::LanguageId::Ruby
       end
+
       set(uri: uri, source: File.binread(path), version: 0, language_id: language_id)
       T.must(@state[uri.to_s])
     rescue Errno::ENOENT

data/lib/ruby_lsp/test_helper.rb

@@ -21,7 +21,7 @@ module RubyLsp
       &block)
       server = RubyLsp::Server.new(test_mode: true)
       server.global_state.stubs(:has_type_checker).returns(false) if stub_no_typechecker
-      server.global_state.apply_options({})
+      server.global_state.apply_options({ initializationOptions: { experimentalFeaturesEnabled: true } })
       language_id = uri.to_s.end_with?(".erb") ? "erb" : "ruby"
 
       if source

data/lib/ruby_lsp/type_inferrer.rb

@@ -7,12 +7,16 @@ module RubyLsp
   class TypeInferrer
     extend T::Sig
 
-    sig { params(index: RubyIndexer::Index).void }
-    def initialize(index)
+    sig { params(experimental_features: T::Boolean).returns(T::Boolean) }
+    attr_writer :experimental_features
+
+    sig { params(index: RubyIndexer::Index, experimental_features: T::Boolean).void }
+    def initialize(index, experimental_features = true)
       @index = index
+      @experimental_features = experimental_features
     end
 
-    sig { params(node_context: NodeContext).returns(T.nilable(String)) }
+    sig { params(node_context: NodeContext).returns(T.nilable(Type)) }
     def infer_receiver_type(node_context)
       node = node_context.node
 
@@ -28,7 +32,7 @@ module RubyLsp
 
     private
 
-    sig { params(node: Prism::CallNode, node_context: NodeContext).returns(T.nilable(String)) }
+    sig { params(node: Prism::CallNode, node_context: NodeContext).returns(T.nilable(Type)) }
     def infer_receiver_for_call_node(node, node_context)
       receiver = node.receiver
 
@@ -47,23 +51,40 @@ module RubyLsp
         return unless name
 
         *parts, last = name.split("::")
-        return "#{last}::<Class:#{last}>" if parts.empty?
+        return Type.new("#{last}::<Class:#{last}>") if parts.empty?
+
+        Type.new("#{parts.join("::")}::#{last}::<Class:#{last}>")
+      else
+        return unless @experimental_features
+
+        raw_receiver = node.receiver&.slice
 
-        "#{parts.join("::")}::#{last}::<Class:#{last}>"
+        if raw_receiver
+          guessed_name = raw_receiver
+            .delete_prefix("@")
+            .delete_prefix("@@")
+            .split("_")
+            .map(&:capitalize)
+            .join
+
+          entries = @index.resolve(guessed_name, node_context.nesting) || @index.first_unqualified_const(guessed_name)
+          name = entries&.first&.name
+          GuessedType.new(name) if name
+        end
       end
     end
 
-    sig { params(node_context: NodeContext).returns(String) }
+    sig { params(node_context: NodeContext).returns(Type) }
     def self_receiver_handling(node_context)
       nesting = node_context.nesting
       # If we're at the top level, then the invocation is happening on `<main>`, which is a special singleton that
       # inherits from Object
-      return "Object" if nesting.empty?
-      return node_context.fully_qualified_name if node_context.surrounding_method
+      return Type.new("Object") if nesting.empty?
+      return Type.new(node_context.fully_qualified_name) if node_context.surrounding_method
 
       # If we're not inside a method, then we're inside the body of a class or module, which is a singleton
       # context
-      "#{nesting.join("::")}::<Class:#{nesting.last}>"
+      Type.new("#{nesting.join("::")}::<Class:#{nesting.last}>")
     end
 
     sig do
@@ -80,5 +101,22 @@ module RubyLsp
            Prism::ConstantPathNode::MissingNodesInConstantPathError
       nil
     end
+
+    # A known type
+    class Type
+      extend T::Sig
+
+      sig { returns(String) }
+      attr_reader :name
+
+      sig { params(name: String).void }
+      def initialize(name)
+        @name = name
+      end
+    end
+
+    # A type that was guessed based on the receiver raw name
+    class GuessedType < Type
+    end
   end
 end

data/lib/ruby_lsp/utils.rb

@@ -25,6 +25,7 @@ module RubyLsp
     end,
     String,
   )
+  GUESSED_TYPES_URL = "https://github.com/Shopify/ruby-lsp/blob/main/DESIGN_AND_ROADMAP.md#guessed-types"
 
   # A notification to be sent to the client
   class Message

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.17.8
+  version: 0.17.9
 platform: ruby
 authors:
 - Shopify
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-07-18 00:00:00.000000000 Z
+date: 2024-07-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: language_server-protocol
@@ -204,7 +204,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.15
+rubygems_version: 3.5.16
 signing_key:
 specification_version: 4
 summary: An opinionated language server for Ruby