ruby-lsp 0.27.0.beta3 → 0.27.0.beta4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b3bc7e833f5619665b205e3346555594540a1150cf4a66514ed1fe6900fc8d0e
-  data.tar.gz: c7cf77eed53ba29b680221474abffd5356f723dd4bb2bd586b8158c5b3794dba
+  metadata.gz: de1859a4f73bdc2007364195d5e2c8aae9f999455a7523ad290263efb0edab30
+  data.tar.gz: 63e9388bc11ef954ed197db00c166a900e0f422c346c48af7bc485ab51a630c8
 SHA512:
-  metadata.gz: 3b265bbdf75bd46df7acc181a9d77aced50b403b5efa21dc7c22eeda92b5b0319b5d1ac21a279d2c436c5126026c3f643760974c57d26bbbcc32ca69fba5b9bc
-  data.tar.gz: ee7b8e028a2a38e301ec14c33c2a7c6f292e89f1c850a935b26dce19bc4a10f15915a07c2dea8f8e32839acd3018f7613e698a06d6e908b3334d38cccddd47de
+  metadata.gz: cade33d50651fb915408b36b0537cb201c9b61ee0151e2ae6a8a1bee3099054af2a184e93b7790a0d283860159326f31d391c71bda798f00229262c4c58123f2
+  data.tar.gz: 01f24b527c33cc3d741fe682d79b70a0881760a9dc6d599101356563cbfce30ce0e719619312f530f42256b6ecb82ac2a40c93d6cde0ad97ef5e2a8087922d3d

data/VERSION

@@ -1 +1 @@
-0.27.0.beta3
+0.27.0.beta4

data/lib/ruby_lsp/base_server.rb

@@ -74,6 +74,8 @@ module RubyLsp
                   )
                 end
               end
+            rescue URI::Error
+              # A client can send a document URI with a scheme Ruby's URI parser rejects, so we don't want to fail
             rescue Store::NonExistingDocumentError
               # If we receive a request for a file that no longer exists, we don't want to fail
             end

data/lib/ruby_lsp/listeners/completion.rb

@@ -256,7 +256,7 @@ module RubyLsp
       #
       #: () -> Array[(Rubydex::Declaration | Rubydex::Keyword)]
       def expression_candidates
-        @graph.complete_expression(@node_context.nesting, self_receiver: nil)
+        @graph.complete_expression(@node_context.nesting, self_receiver: @type_inferrer.self_receiver_name(@node_context))
       end
 
       #: (Interface::Range range, String prefix) -> void
@@ -322,14 +322,14 @@ module RubyLsp
         end
 
         candidates = if namespace_prefix.empty?
-          @graph.complete_expression([], self_receiver: nil)
+          @graph.complete_expression([], self_receiver: @type_inferrer.self_receiver_name(@node_context))
         else
           # Rubydex's resolver handles a leading `::` on `namespace_prefix` by resolving from the top-level scope, so
           # we don't need to special-case top-level references here
           resolved = @graph.resolve_constant(namespace_prefix, @node_context.nesting)
           return unless resolved
 
-          @graph.complete_namespace_access(resolved.name, self_receiver: nil)
+          @graph.complete_namespace_access(resolved.name, self_receiver: @type_inferrer.self_receiver_name(@node_context))
         end
 
         candidates.each do |candidate|
@@ -378,7 +378,7 @@ module RubyLsp
 
         guessed_type = type.is_a?(TypeInferrer::GuessedType) && type.name
 
-        @graph.complete_method_call(type.name, self_receiver: nil).each do |candidate|
+        @graph.complete_method_call(type.name, self_receiver: @type_inferrer.self_receiver_name(@node_context)).each do |candidate|
           if method_name
             display_name = candidate.unqualified_name.delete_suffix("()")
             next unless display_name.start_with?(method_name)
@@ -390,16 +390,13 @@ module RubyLsp
 
       # Variable completion (instance, class, and global). The variable kind is selected by the prefix the user typed:
       # `$…` only matches globals, `@@…` only class variables, and `@…` matches both instance and class variables (since
-      # `@@foo`.start_with?("@") is true). Globals live at top-level, so they need an empty nesting; instance/class
-      # variables resolve through the type_inferrer to handle singleton methods and class bodies, where the receiver is
-      # the singleton class rather than the lexical nesting.
+      # `@@foo`.start_with?("@") is true). This uses the same query as expression completion: the lexical nesting drives
+      # constants and class variables, while the `self` type (which may differ from the nesting, e.g. inside
+      # `def self.foo` or `def Bar.baz`) drives instance variables.
       #
       #: (Interface::Range, String) -> void
       def complete_variable(range, prefix)
-        type = @type_inferrer.infer_receiver_type(@node_context)
-        nesting = type ? type.name.split("::") : []
-
-        @graph.complete_expression(nesting, self_receiver: nil).each do |candidate|
+        expression_candidates.each do |candidate|
           next unless candidate.is_a?(Rubydex::Declaration)
 
           variable_name = candidate.unqualified_name

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

@@ -120,6 +120,16 @@ module RubyLsp
           markdown_title = "```ruby\n#{title}\n```"
           file_links = []
           content = +""
+
+          # Include documentation for method alias targets
+          definitions = definitions.flat_map do |definition|
+            if definition.is_a?(Rubydex::MethodAliasDefinition) && (target = definition.target)
+              [definition, *target.definitions]
+            else
+              [definition]
+            end
+          end
+
           defs = max_entries ? definitions.take(max_entries) : definitions
           defs.each do |definition|
             # For Markdown links, we need 1 based display locations

data/lib/ruby_lsp/server.rb

@@ -371,6 +371,7 @@ module RubyLsp
         end
       end
 
+      load_rubydex_config
       perform_initial_indexing
       check_formatter_is_available
       update_server if @global_state.enabled_feature?(:launcher)
@@ -435,10 +436,15 @@ module RubyLsp
       if [:ruby, :rbs].include?(language_id)
         graph = @global_state.graph
 
-        benchmark("index_source") do
-          graph.index_source(text_document[:uri].to_s, document.source, language_id.to_s)
-        end
+        begin_progress("incremental-indexing-progress", "Ruby LSP: indexing files")
+
+        progress("incremental-indexing-progress", message: "Indexing file...")
+        benchmark("index_source") { graph.index_source(text_document[:uri].to_s, document.source, language_id.to_s) }
+
+        progress("incremental-indexing-progress", message: "Resolving graph...")
         benchmark("incremental_resolve") { graph.resolve }
+
+        end_progress("incremental-indexing-progress")
       end
     end
 
@@ -1032,9 +1038,17 @@ module RubyLsp
           acc << path
         end
       end
+
+      begin_progress("incremental-indexing-progress", "Ruby LSP: indexing files")
+
+      progress("incremental-indexing-progress", message: "Indexing files...")
       benchmark("index_all") { graph.index_all(additions_and_changes) }
+
+      progress("incremental-indexing-progress", message: "Resolving graph...")
       benchmark("incremental_resolve") { graph.resolve }
 
+      end_progress("incremental-indexing-progress")
+
       changes.each do |change|
         # File change events include folders, but we're only interested in files
         uri = URI(change[:uri])
@@ -1209,8 +1223,8 @@ module RubyLsp
       end_progress("indexing-progress")
     end
 
-    #: (String id, String title, ?percentage: Integer) -> void
-    def begin_progress(id, title, percentage: 0)
+    #: (String id, String title, ?percentage: Integer?, ?message: String?) -> void
+    def begin_progress(id, title, percentage: nil, message: nil)
       return unless @global_state.client_capabilities.supports_progress
 
       send_message(Request.new(
@@ -1219,7 +1233,10 @@ module RubyLsp
         params: Interface::WorkDoneProgressCreateParams.new(token: id),
       ))
 
-      send_message(Notification.progress_begin(id, title, percentage: percentage, message: "#{percentage}% completed"))
+      # Omitting the percentage tells the client to show indefinite progress. Only fabricate a "% completed" message
+      # when a caller reports incremental percentages and didn't provide an explicit message
+      message ||= "#{percentage}% completed" if percentage
+      send_message(Notification.progress_begin(id, title, percentage: percentage, message: message))
     end
 
     #: (String, ?message: String?, ?percentage: Integer?) -> void
@@ -1443,5 +1460,15 @@ module RubyLsp
 
       result
     end
+
+    #: () -> void
+    def load_rubydex_config
+      @global_state.graph.load_config
+    rescue Rubydex::ConfigError => e
+      send_message(Notification.window_show_message(
+        "Error loading rubydex config: #{e.message}",
+        type: Constant::MessageType::ERROR,
+      ))
+    end
   end
 end

data/lib/ruby_lsp/setup_bundler.rb

@@ -445,7 +445,7 @@ module RubyLsp
       requirement = Gem::Requirement.new(@bundler_version.to_s)
       return if Gem::Specification.any? { |s| s.name == "bundler" && requirement =~ s.version }
 
-      Gem.install("bundler", @bundler_version.to_s)
+      Gem.install("bundler", @bundler_version.to_s, env_shebang: true)
     end
 
     #: -> bool

data/lib/ruby_lsp/type_inferrer.rb

@@ -20,13 +20,67 @@ module RubyLsp
       when Prism::InstanceVariableReadNode, Prism::InstanceVariableAndWriteNode, Prism::InstanceVariableWriteNode,
         Prism::InstanceVariableOperatorWriteNode, Prism::InstanceVariableOrWriteNode, Prism::InstanceVariableTargetNode,
         Prism::SuperNode, Prism::ForwardingSuperNode, Prism::DefNode
-        self_receiver_handling(node_context)
+        infer_self_type(node_context)
       when Prism::ClassVariableAndWriteNode, Prism::ClassVariableWriteNode, Prism::ClassVariableOperatorWriteNode,
         Prism::ClassVariableOrWriteNode, Prism::ClassVariableReadNode, Prism::ClassVariableTargetNode
         infer_receiver_for_class_variables(node_context)
       end
     end
 
+    # Infers the type of `self` in the given context. Unlike `infer_receiver_type`, this does not depend on the node
+    # being completed — it's derived purely from the lexical nesting and the surrounding method's receiver. This matters
+    # because methods and instance variables are attached to the type of `self`, which doesn't always match the lexical
+    # scope (e.g. inside `def self.foo` or a class/module body).
+    #
+    #: (NodeContext node_context) -> Type?
+    def infer_self_type(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 Type.new("Object") if nesting.empty?
+
+      surrounding_method = node_context.surrounding_method
+
+      if surrounding_method
+        receiver_name = surrounding_method.receiver
+
+        case receiver_name
+        when "self"
+          # `def self.foo` — self is the singleton of the enclosing class/module
+          return resolve_singleton_type_from_nesting(nesting)
+        when "none"
+          # Instance method — self is an instance of the enclosing class/module
+          return resolve_type_from_nesting(nesting)
+        when nil
+          # Dynamic receiver that we cannot handle
+          return
+        else
+          # Explicit constant receiver (e.g. `def Bar.baz`) — self is that constant's singleton class
+          resolved = resolve_receiver_singleton_type(receiver_name, nesting)
+          return resolved if resolved
+
+          return resolve_type_from_nesting(nesting)
+        end
+      end
+
+      # If we're not inside a method, then we're inside the body of a class or module, which is a singleton
+      # context. Resolve through the graph to get the correct fully qualified name
+      resolve_singleton_type_from_nesting(nesting)
+    end
+
+    # The type of `self`, which may or may not match the current lexical scope. For example, if we have `def Bar.foo` or
+    # if something else mutates the type
+    #
+    #: (NodeContext) -> String?
+    def self_receiver_name(node_context)
+      return if node_context.nesting.empty?
+
+      name = infer_self_type(node_context)&.name
+      return unless name
+
+      name if @graph[name]
+    end
+
     private
 
     #: (Prism::CallNode node, NodeContext node_context) -> Type?
@@ -49,7 +103,7 @@ module RubyLsp
 
       case receiver
       when Prism::SelfNode, nil
-        self_receiver_handling(node_context)
+        infer_self_type(node_context)
       when Prism::StringNode
         Type.new("String")
       when Prism::SymbolNode
@@ -129,42 +183,6 @@ module RubyLsp
       GuessedType.new(declaration.name)
     end
 
-    #: (NodeContext node_context) -> 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 Type.new("Object") if nesting.empty?
-
-      surrounding_method = node_context.surrounding_method
-
-      if surrounding_method
-        receiver_name = surrounding_method.receiver
-
-        case receiver_name
-        when "self"
-          # `def self.foo` — self is the singleton of the enclosing class/module
-          return resolve_singleton_type_from_nesting(nesting)
-        when "none"
-          # Instance method — self is an instance of the enclosing class/module
-          return resolve_type_from_nesting(nesting)
-        when nil
-          # Dynamic receiver that we cannot handle
-          return
-        else
-          # Explicit constant receiver (e.g. `def Bar.baz`) — self is that constant's singleton class
-          resolved = resolve_receiver_singleton_type(receiver_name, nesting)
-          return resolved if resolved
-
-          return resolve_type_from_nesting(nesting)
-        end
-      end
-
-      # If we're not inside a method, then we're inside the body of a class or module, which is a singleton
-      # context. Resolve through the graph to get the correct fully qualified name
-      resolve_singleton_type_from_nesting(nesting)
-    end
-
     # Resolves the fully qualified name of the innermost constant from the nesting and returns it as a type.
     # For instance methods, the nesting won't have singleton markers, so the result is an instance type.
     # For `def self.` methods, the nesting includes a singleton marker, which is preserved in the result.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.27.0.beta3
+  version: 0.27.0.beta4
 platform: ruby
 authors:
 - Shopify
@@ -67,9 +67,9 @@ dependencies:
   name: rubydex
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.2.0
+        version: 0.2.7
     - - "<"
       - !ruby/object:Gem::Version
         version: 0.3.0
@@ -77,9 +77,9 @@ dependencies:
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.2.0
+        version: 0.2.7
     - - "<"
       - !ruby/object:Gem::Version
         version: 0.3.0
@@ -213,7 +213,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.3
+rubygems_version: 4.0.10
 specification_version: 4
 summary: An opinionated language server for Ruby
 test_files: []