ruby-lsp 0.17.16 → 0.17.17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fc4416ea8876d8207b6c1955cd47af5f3312a0f0dc3644563bfd35138a903535
-  data.tar.gz: 5961dd8ca49539c20049509c0afed8b2442c3d16ec12d1fb84c9e45dbd027760
+  metadata.gz: e4b4c9204834ddf87c84009003c5eef5872211eaef6ed64022a93a2749e1849e
+  data.tar.gz: 0d770cf2f67f90fb974a9fca08d9fb4dea1a73d668984ff96e5cc5785d7c5766
 SHA512:
-  metadata.gz: 4b77547221c1750871ff6e1a3635b0ae6f945b86862f484d20eb7587a1feb9830e1d1d7770f16c2e7efeb70e6a953529041f8acc8fe3d7c30940687d20563f96
-  data.tar.gz: 1093a1a6ac45e8627f26a6c9dbb0017079d2804904fe9a4303e3698d4131c6eeedf2bbafac93e6475f676860624b9c53d482c52cfe8380e67ed05ce525e99957
+  metadata.gz: 3534227d67761a6738c5e2ae4a06a08964a0836c4a30c9d306917efdd93aae1285d6ed03992e88486a44e5d3f7e7271997e56bbb12ab908599687c6a1e622cb4
+  data.tar.gz: 5345bcf362b6206a0be392eebe5db2175fe9d06b1a38f113fe11d979e5fdcc48851cb47e5f016ae49726ffc73432e81ef801522588cee79ebb36fe545e02d965

data/VERSION

@@ -1 +1 @@
-0.17.16
+0.17.17

data/exe/ruby-lsp

@@ -98,16 +98,17 @@ if options[:debug]
 end
 
 if options[:time_index]
-  require "benchmark"
-
   index = RubyIndexer::Index.new
 
-  result = Benchmark.realtime { index.index_all }
+  time_start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  index.index_all
+  elapsed_time = Process.clock_gettime(Process::CLOCK_MONOTONIC) - time_start
+
   entries = index.instance_variable_get(:@entries)
   entries_by_entry_type = entries.values.flatten.group_by(&:class)
 
   puts <<~MSG
-    Ruby LSP v#{RubyLsp::VERSION}: Indexing took #{result.round(5)} seconds and generated:
+    Ruby LSP v#{RubyLsp::VERSION}: Indexing took #{elapsed_time.round(5)} seconds and generated:
     - #{entries_by_entry_type.sort_by { |k, _| k.to_s }.map { |k, v| "#{k.name.split("::").last}: #{v.size}" }.join("\n- ")}
   MSG
   return

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

@@ -232,7 +232,7 @@ module RubyIndexer
         next unless ancestor_index && (!existing_entry || ancestor_index < existing_entry_index)
 
         if entry.is_a?(Entry::UnresolvedMethodAlias)
-          resolved_alias = resolve_method_alias(entry, receiver_name)
+          resolved_alias = resolve_method_alias(entry, receiver_name, [])
           hash[entry_name] = [resolved_alias, ancestor_index] if resolved_alias.is_a?(Entry::MethodAlias)
         else
           hash[entry_name] = [entry, ancestor_index]
@@ -394,16 +394,18 @@ module RubyIndexer
       real_parts.join("::")
     end
 
-    # Attempts to find methods for a resolved fully qualified receiver name.
+    # Attempts to find methods for a resolved fully qualified receiver name. Do not provide the `seen_names` parameter
+    # as it is used only internally to prevent infinite loops when resolving circular aliases
     # Returns `nil` if the method does not exist on that receiver
     sig do
       params(
         method_name: String,
         receiver_name: String,
+        seen_names: T::Array[String],
         inherited_only: T::Boolean,
       ).returns(T.nilable(T::Array[T.any(Entry::Member, Entry::MethodAlias)]))
     end
-    def resolve_method(method_name, receiver_name, inherited_only: false)
+    def resolve_method(method_name, receiver_name, seen_names = [], inherited_only: false)
       method_entries = self[method_name]
       return unless method_entries
 
@@ -418,7 +420,7 @@ module RubyIndexer
           when Entry::UnresolvedMethodAlias
             # Resolve aliases lazily as we find them
             if entry.owner&.name == ancestor
-              resolved_alias = resolve_method_alias(entry, receiver_name)
+              resolved_alias = resolve_method_alias(entry, receiver_name, seen_names)
               resolved_alias if resolved_alias.is_a?(Entry::MethodAlias)
             end
           end
@@ -614,6 +616,17 @@ module RubyIndexer
       singleton
     end
 
+    sig do
+      type_parameters(:T).params(
+        path: String,
+        type: T::Class[T.all(T.type_parameter(:T), Entry)],
+      ).returns(T.nilable(T::Array[T.type_parameter(:T)]))
+    end
+    def entries_for(path, type)
+      entries = @files_to_entries[path]
+      entries&.grep(type)
+    end
+
     private
 
     # Runs the registered included hooks
@@ -919,16 +932,21 @@ module RubyIndexer
       params(
         entry: Entry::UnresolvedMethodAlias,
         receiver_name: String,
+        seen_names: T::Array[String],
       ).returns(T.any(Entry::MethodAlias, Entry::UnresolvedMethodAlias))
     end
-    def resolve_method_alias(entry, receiver_name)
-      return entry if entry.new_name == entry.old_name
+    def resolve_method_alias(entry, receiver_name, seen_names)
+      new_name = entry.new_name
+      return entry if new_name == entry.old_name
+      return entry if seen_names.include?(new_name)
+
+      seen_names << new_name
 
-      target_method_entries = resolve_method(entry.old_name, receiver_name)
+      target_method_entries = resolve_method(entry.old_name, receiver_name, seen_names)
       return entry unless target_method_entries
 
       resolved_alias = Entry::MethodAlias.new(T.must(target_method_entries.first), entry)
-      original_entries = T.must(@entries[entry.new_name])
+      original_entries = T.must(@entries[new_name])
       original_entries.delete(entry)
       original_entries << resolved_alias
       resolved_alias

data/lib/ruby_indexer/test/index_test.rb

@@ -1822,5 +1822,46 @@ module RubyIndexer
         @index.linearized_ancestors_of("Foo::Child::<Class:Child>"),
       )
     end
+
+    def test_resolving_circular_method_aliases_on_class_reopen
+      index(<<~RUBY)
+        class Foo
+          alias bar ==
+          def ==(other) = true
+        end
+
+        class Foo
+          alias == bar
+        end
+      RUBY
+
+      method = @index.resolve_method("==", "Foo").first
+      assert_kind_of(Entry::Method, method)
+      assert_equal("==", method.name)
+
+      candidates = @index.method_completion_candidates("=", "Foo")
+      assert_equal(["==", "==="], candidates.map(&:name))
+    end
+
+    def test_entries_for
+      index(<<~RUBY)
+        class Foo; end
+
+        module Bar
+          def my_def; end
+          def self.my_singleton_def; end
+        end
+      RUBY
+
+      entries = @index.entries_for("/fake/path/foo.rb", Entry)
+      assert_equal(["Foo", "Bar", "my_def", "Bar::<Class:Bar>", "my_singleton_def"], entries.map(&:name))
+
+      entries = @index.entries_for("/fake/path/foo.rb", RubyIndexer::Entry::Namespace)
+      assert_equal(["Foo", "Bar", "Bar::<Class:Bar>"], entries.map(&:name))
+    end
+
+    def test_entries_for_returns_nil_if_no_matches
+      assert_nil(@index.entries_for("non_existing_file.rb", Entry::Namespace))
+    end
   end
 end

data/lib/ruby_lsp/addon.rb

@@ -30,6 +30,8 @@ module RubyLsp
     # Addon instances that have declared a handler to accept file watcher events
     @file_watcher_addons = T.let([], T::Array[Addon])
 
+    AddonNotFoundError = Class.new(StandardError)
+
     class << self
       extend T::Sig
 
@@ -78,11 +80,10 @@ module RubyLsp
         errors
       end
 
-      # Intended for use by tests for addons
       sig { params(addon_name: String).returns(Addon) }
       def get(addon_name)
         addon = addons.find { |addon| addon.name == addon_name }
-        raise "Could not find addon '#{addon_name}'" unless addon
+        raise AddonNotFoundError, "Could not find addon '#{addon_name}'" unless addon
 
         addon
       end

data/lib/ruby_lsp/global_state.rb

@@ -40,6 +40,12 @@ module RubyLsp
       @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)
+      @addon_settings = T.let({}, T::Hash[String, T.untyped])
+    end
+
+    sig { params(addon_name: String).returns(T.nilable(T::Hash[Symbol, T.untyped])) }
+    def settings_for_addon(addon_name)
+      @addon_settings[addon_name]
     end
 
     sig { params(identifier: String, instance: Requests::Support::Formatter).void }
@@ -119,6 +125,12 @@ module RubyLsp
       @experimental_features = options.dig(:initializationOptions, :experimentalFeaturesEnabled) || false
       @type_inferrer.experimental_features = @experimental_features
 
+      addon_settings = options.dig(:initializationOptions, :addonSettings)
+      if addon_settings
+        addon_settings.transform_keys!(&:to_s)
+        @addon_settings.merge!(addon_settings)
+      end
+
       notifications
     end
 

data/lib/ruby_lsp/listeners/folding_ranges.rb

@@ -242,7 +242,7 @@ module RubyLsp
         body = statements.body
         return if body.empty?
 
-        add_lines_range(node.location.start_line, T.must(body.last).location.end_line)
+        add_lines_range(node.location.start_line, body.last.location.end_line)
       end
 
       sig { params(node: Prism::Node).void }

data/lib/ruby_lsp/listeners/semantic_highlighting.rb

@@ -41,6 +41,7 @@ module RubyLsp
           :on_block_node_leave,
           :on_self_node_enter,
           :on_module_node_enter,
+          :on_local_variable_write_node_enter,
           :on_local_variable_read_node_enter,
           :on_block_parameter_node_enter,
           :on_required_keyword_parameter_node_enter,
@@ -49,6 +50,9 @@ module RubyLsp
           :on_optional_parameter_node_enter,
           :on_required_parameter_node_enter,
           :on_rest_parameter_node_enter,
+          :on_local_variable_and_write_node_enter,
+          :on_local_variable_operator_write_node_enter,
+          :on_local_variable_or_write_node_enter,
           :on_local_variable_target_node_enter,
           :on_block_local_variable_node_enter,
           :on_match_write_node_enter,
@@ -164,6 +168,12 @@ module RubyLsp
         @response_builder.add_token(node.location, :variable, [:default_library])
       end
 
+      sig { params(node: Prism::LocalVariableWriteNode).void }
+      def on_local_variable_write_node_enter(node)
+        type = @current_scope.type_for(node.name)
+        @response_builder.add_token(node.name_loc, type) if type == :parameter
+      end
+
       sig { params(node: Prism::LocalVariableReadNode).void }
       def on_local_variable_read_node_enter(node)
         return if @inside_implicit_node
@@ -177,6 +187,24 @@ module RubyLsp
         @response_builder.add_token(node.location, @current_scope.type_for(node.name))
       end
 
+      sig { params(node: Prism::LocalVariableAndWriteNode).void }
+      def on_local_variable_and_write_node_enter(node)
+        type = @current_scope.type_for(node.name)
+        @response_builder.add_token(node.name_loc, type) if type == :parameter
+      end
+
+      sig { params(node: Prism::LocalVariableOperatorWriteNode).void }
+      def on_local_variable_operator_write_node_enter(node)
+        type = @current_scope.type_for(node.name)
+        @response_builder.add_token(node.name_loc, type) if type == :parameter
+      end
+
+      sig { params(node: Prism::LocalVariableOrWriteNode).void }
+      def on_local_variable_or_write_node_enter(node)
+        type = @current_scope.type_for(node.name)
+        @response_builder.add_token(node.name_loc, type) if type == :parameter
+      end
+
       sig { params(node: Prism::LocalVariableTargetNode).void }
       def on_local_variable_target_node_enter(node)
         # If we're inside a regex capture, Prism will add LocalVariableTarget nodes for each captured variable.

data/lib/ruby_lsp/requests/formatting.rb

@@ -58,14 +58,16 @@ module RubyLsp
         formatted_text = @active_formatter.run_formatting(@uri, @document)
         return unless formatted_text
 
+        lines = @document.source.lines
         size = @document.source.size
+
         return if formatted_text.size == size && formatted_text == @document.source
 
         [
           Interface::TextEdit.new(
             range: Interface::Range.new(
               start: Interface::Position.new(line: 0, character: 0),
-              end: Interface::Position.new(line: size, character: size),
+              end: Interface::Position.new(line: lines.size, character: 0),
             ),
             new_text: formatted_text,
           ),

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.17.16
+  version: 0.17.17
 platform: ruby
 authors:
 - Shopify
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-08-26 00:00:00.000000000 Z
+date: 2024-08-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: language_server-protocol
@@ -28,22 +28,16 @@ dependencies:
   name: prism
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.29.0
-    - - "<"
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.31'
+        version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.29.0
-    - - "<"
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.31'
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: rbs
   requirement: !ruby/object:Gem::Requirement