ruby-lsp 0.12.2 → 0.13.0

data/lib/ruby_indexer/test/index_test.rb

@@ -193,5 +193,69 @@ module RubyIndexer
 
       assert_instance_of(Entry::UnresolvedAlias, entry)
     end
+
+    def test_visitor_does_not_visit_unnecessary_nodes
+      concats = (0...10_000).map do |i|
+        <<~STRING
+          "string#{i}" \\
+        STRING
+      end.join
+
+      index(<<~RUBY)
+        module Foo
+          local_var = #{concats}
+            "final"
+          @class_instance_var = #{concats}
+            "final"
+          @@class_var = #{concats}
+            "final"
+          $global_var = #{concats}
+            "final"
+          CONST = #{concats}
+            "final"
+        end
+      RUBY
+    end
+
+    def test_resolve_method_with_known_receiver
+      index(<<~RUBY)
+        module Foo
+          module Bar
+            def baz; end
+          end
+        end
+      RUBY
+
+      entry = T.must(@index.resolve_method("baz", "Foo::Bar"))
+      assert_equal("baz", entry.name)
+      assert_equal("Foo::Bar", T.must(entry.owner).name)
+    end
+
+    def test_prefix_search_for_methods
+      index(<<~RUBY)
+        module Foo
+          module Bar
+            def baz; end
+          end
+        end
+      RUBY
+
+      entries = @index.prefix_search("ba")
+      refute_empty(entries)
+
+      entry = T.must(entries.first).first
+      assert_equal("baz", entry.name)
+    end
+
+    def test_indexing_prism_fixtures_succeeds
+      fixtures = Dir.glob("test/fixtures/prism/test/prism/fixtures/**/*.txt")
+
+      fixtures.each do |fixture|
+        indexable_path = IndexablePath.new("", fixture)
+        @index.index_single(indexable_path)
+      end
+
+      refute_empty(@index.instance_variable_get(:@entries))
+    end
   end
 end

data/lib/ruby_indexer/test/method_test.rb

@@ -69,5 +69,85 @@ module RubyIndexer
       assert_equal(:"(a, (b, ))", parameter.name)
       assert_instance_of(Entry::RequiredParameter, parameter)
     end
+
+    def test_method_with_optional_parameters
+      index(<<~RUBY)
+        class Foo
+          def bar(a = 123)
+          end
+        end
+      RUBY
+
+      assert_entry("bar", Entry::InstanceMethod, "/fake/path/foo.rb:1-2:2-5")
+      entry = T.must(@index["bar"].first)
+      assert_equal(1, entry.parameters.length)
+      parameter = entry.parameters.first
+      assert_equal(:a, parameter.name)
+      assert_instance_of(Entry::OptionalParameter, parameter)
+    end
+
+    def test_method_with_keyword_parameters
+      index(<<~RUBY)
+        class Foo
+          def bar(a:, b: 123)
+          end
+        end
+      RUBY
+
+      assert_entry("bar", Entry::InstanceMethod, "/fake/path/foo.rb:1-2:2-5")
+      entry = T.must(@index["bar"].first)
+      assert_equal(2, entry.parameters.length)
+      a, b = entry.parameters
+
+      assert_equal(:a, a.name)
+      assert_instance_of(Entry::KeywordParameter, a)
+
+      assert_equal(:b, b.name)
+      assert_instance_of(Entry::OptionalKeywordParameter, b)
+    end
+
+    def test_keeps_track_of_method_owner
+      index(<<~RUBY)
+        class Foo
+          def bar
+          end
+        end
+      RUBY
+
+      entry = T.must(@index["bar"].first)
+      owner_name = T.must(entry.owner).name
+
+      assert_equal("Foo", owner_name)
+    end
+
+    def test_keeps_track_of_attributes
+      index(<<~RUBY)
+        class Foo
+          # Hello there
+          attr_reader :bar, :other
+          attr_writer :baz
+          attr_accessor :qux
+        end
+      RUBY
+
+      assert_entry("bar", Entry::Accessor, "/fake/path/foo.rb:2-15:2-18")
+      assert_equal("Hello there", @index["bar"].first.comments.join("\n"))
+      assert_entry("other", Entry::Accessor, "/fake/path/foo.rb:2-21:2-26")
+      assert_equal("Hello there", @index["other"].first.comments.join("\n"))
+      assert_entry("baz=", Entry::Accessor, "/fake/path/foo.rb:3-15:3-18")
+      assert_entry("qux", Entry::Accessor, "/fake/path/foo.rb:4-17:4-20")
+      assert_entry("qux=", Entry::Accessor, "/fake/path/foo.rb:4-17:4-20")
+    end
+
+    def test_ignores_attributes_invoked_on_constant
+      index(<<~RUBY)
+        class Foo
+        end
+
+        Foo.attr_reader :bar
+      RUBY
+
+      assert_no_entry("bar")
+    end
   end
 end

data/lib/ruby_lsp/addon.rb

@@ -41,8 +41,8 @@ module RubyLsp
       end
 
       # Discovers and loads all addons. Returns the list of activated addons
-      sig { returns(T::Array[Addon]) }
-      def load_addons
+      sig { params(message_queue: Thread::Queue).returns(T::Array[Addon]) }
+      def load_addons(message_queue)
         # Require all addons entry points, which should be placed under
         # `some_gem/lib/ruby_lsp/your_gem_name/addon.rb`
         Gem.find_files("ruby_lsp/**/addon.rb").each do |addon|
@@ -55,7 +55,7 @@ module RubyLsp
         # Activate each one of the discovered addons. If any problems occur in the addons, we don't want to
         # fail to boot the server
         addons.each do |addon|
-          addon.activate
+          addon.activate(message_queue)
           nil
         rescue => e
           addon.add_error(e)
@@ -94,8 +94,8 @@ module RubyLsp
 
     # Each addon should implement `MyAddon#activate` and use to perform any sort of initialization, such as
     # reading information into memory or even spawning a separate process
-    sig { abstract.void }
-    def activate; end
+    sig { abstract.params(message_queue: Thread::Queue).void }
+    def activate(message_queue); end
 
     # Each addon should implement `MyAddon#deactivate` and use to perform any clean up, like shutting down a
     # child process
@@ -111,10 +111,9 @@ module RubyLsp
       overridable.params(
         uri: URI::Generic,
         dispatcher: Prism::Dispatcher,
-        message_queue: Thread::Queue,
       ).returns(T.nilable(Listener[T::Array[Interface::CodeLens]]))
     end
-    def create_code_lens_listener(uri, dispatcher, message_queue); end
+    def create_code_lens_listener(uri, dispatcher); end
 
     # Creates a new Hover listener. This method is invoked on every Hover request
     sig do
@@ -122,19 +121,17 @@ module RubyLsp
         nesting: T::Array[String],
         index: RubyIndexer::Index,
         dispatcher: Prism::Dispatcher,
-        message_queue: Thread::Queue,
       ).returns(T.nilable(Listener[T.nilable(Interface::Hover)]))
     end
-    def create_hover_listener(nesting, index, dispatcher, message_queue); end
+    def create_hover_listener(nesting, index, dispatcher); end
 
     # Creates a new DocumentSymbol listener. This method is invoked on every DocumentSymbol request
     sig do
       overridable.params(
         dispatcher: Prism::Dispatcher,
-        message_queue: Thread::Queue,
       ).returns(T.nilable(Listener[T::Array[Interface::DocumentSymbol]]))
     end
-    def create_document_symbol_listener(dispatcher, message_queue); end
+    def create_document_symbol_listener(dispatcher); end
 
     # Creates a new Definition listener. This method is invoked on every Definition request
     sig do
@@ -143,9 +140,8 @@ module RubyLsp
         nesting: T::Array[String],
         index: RubyIndexer::Index,
         dispatcher: Prism::Dispatcher,
-        message_queue: Thread::Queue,
       ).returns(T.nilable(Listener[T.nilable(T.any(T::Array[Interface::Location], Interface::Location))]))
     end
-    def create_definition_listener(uri, nesting, index, dispatcher, message_queue); end
+    def create_definition_listener(uri, nesting, index, dispatcher); end
   end
 end

data/lib/ruby_lsp/document.rb

@@ -4,6 +4,9 @@
 module RubyLsp
   class Document
     extend T::Sig
+    extend T::Helpers
+
+    abstract!
 
     PositionShape = T.type_alias { { line: Integer, character: Integer } }
     RangeShape = T.type_alias { { start: PositionShape, end: PositionShape } }
@@ -28,8 +31,8 @@ module RubyLsp
       @source = T.let(source, String)
       @version = T.let(version, Integer)
       @uri = T.let(uri, URI::Generic)
-      @needs_parsing = T.let(false, T::Boolean)
-      @parse_result = T.let(Prism.parse(@source), Prism::ParseResult)
+      @needs_parsing = T.let(true, T::Boolean)
+      @parse_result = T.let(parse, Prism::ParseResult)
     end
 
     sig { returns(Prism::ProgramNode) }
@@ -91,13 +94,8 @@ module RubyLsp
       @cache.clear
     end
 
-    sig { void }
-    def parse
-      return unless @needs_parsing
-
-      @needs_parsing = false
-      @parse_result = Prism.parse(@source)
-    end
+    sig { abstract.returns(Prism::ParseResult) }
+    def parse; end
 
     sig { returns(T::Boolean) }
     def syntax_error?

data/lib/ruby_lsp/executor.rb

@@ -41,7 +41,7 @@ module RubyLsp
       when "initialize"
         initialize_request(request.dig(:params))
       when "initialized"
-        Addon.load_addons
+        Addon.load_addons(@message_queue)
 
         errored_addons = Addon.addons.select(&:error?)
 
@@ -57,6 +57,8 @@ module RubyLsp
           warn(errored_addons.map(&:backtraces).join("\n\n"))
         end
 
+        RubyVM::YJIT.enable if defined? RubyVM::YJIT.enable
+
         perform_initial_indexing
         check_formatter_is_available
 
@@ -93,12 +95,12 @@ module RubyLsp
 
         # Run listeners for the document
         dispatcher = Prism::Dispatcher.new
-        folding_range = Requests::FoldingRanges.new(document.parse_result.comments, dispatcher, @message_queue)
-        document_symbol = Requests::DocumentSymbol.new(dispatcher, @message_queue)
-        document_link = Requests::DocumentLink.new(uri, document.comments, dispatcher, @message_queue)
-        code_lens = Requests::CodeLens.new(uri, dispatcher, @message_queue)
+        folding_range = Requests::FoldingRanges.new(document.parse_result.comments, dispatcher)
+        document_symbol = Requests::DocumentSymbol.new(dispatcher)
+        document_link = Requests::DocumentLink.new(uri, document.comments, dispatcher)
+        code_lens = Requests::CodeLens.new(uri, dispatcher)
 
-        semantic_highlighting = Requests::SemanticHighlighting.new(dispatcher, @message_queue)
+        semantic_highlighting = Requests::SemanticHighlighting.new(dispatcher)
         dispatcher.dispatch(document.tree)
 
         # Store all responses retrieve in this round of visits in the cache and then return the response for the request
@@ -263,13 +265,7 @@ module RubyLsp
       target = parent if target.is_a?(Prism::ConstantReadNode) && parent.is_a?(Prism::ConstantPathNode)
 
       dispatcher = Prism::Dispatcher.new
-      base_listener = Requests::Definition.new(
-        uri,
-        nesting,
-        @index,
-        dispatcher,
-        @message_queue,
-      )
+      base_listener = Requests::Definition.new(uri, nesting, @index, dispatcher)
       dispatcher.dispatch_once(target)
       base_listener.response
     end
@@ -295,7 +291,7 @@ module RubyLsp
 
       # Instantiate all listeners
       dispatcher = Prism::Dispatcher.new
-      hover = Requests::Hover.new(@index, nesting, dispatcher, @message_queue)
+      hover = Requests::Hover.new(@index, nesting, dispatcher)
 
       # Emit events for all listeners
       dispatcher.dispatch_once(target)
@@ -353,6 +349,11 @@ module RubyLsp
       # If formatter is set to `auto` but no supported formatting gem is found, don't attempt to format
       return if @store.formatter == "none"
 
+      # Do not format files outside of the workspace. For example, if someone is looking at a gem's source code, we
+      # don't want to format it
+      path = uri.to_standardized_path
+      return unless path.nil? || path.start_with?(T.must(@store.workspace_uri.to_standardized_path))
+
       Requests::Formatting.new(@store.get(uri), formatter: @store.formatter).run
     end
 
@@ -378,7 +379,7 @@ module RubyLsp
 
       target, parent = document.locate_node(position)
       dispatcher = Prism::Dispatcher.new
-      listener = Requests::DocumentHighlight.new(target, parent, dispatcher, @message_queue)
+      listener = Requests::DocumentHighlight.new(target, parent, dispatcher)
       dispatcher.visit(document.tree)
       listener.response
     end
@@ -391,7 +392,7 @@ module RubyLsp
       end_line = range.dig(:end, :line)
 
       dispatcher = Prism::Dispatcher.new
-      listener = Requests::InlayHints.new(start_line..end_line, dispatcher, @message_queue)
+      listener = Requests::InlayHints.new(start_line..end_line, dispatcher)
       dispatcher.visit(document.tree)
       listener.response
     end
@@ -441,6 +442,11 @@ module RubyLsp
 
     sig { params(uri: URI::Generic).returns(T.nilable(Interface::FullDocumentDiagnosticReport)) }
     def diagnostic(uri)
+      # Do not compute diagnostics for files outside of the workspace. For example, if someone is looking at a gem's
+      # source code, we don't want to show diagnostics for it
+      path = uri.to_standardized_path
+      return unless path.nil? || path.start_with?(T.must(@store.workspace_uri.to_standardized_path))
+
       response = @store.cache_fetch(uri, "textDocument/diagnostic") do |document|
         Requests::Diagnostics.new(document).run
       end
@@ -455,11 +461,7 @@ module RubyLsp
       end_line = range.dig(:end, :line)
 
       dispatcher = Prism::Dispatcher.new
-      listener = Requests::SemanticHighlighting.new(
-        dispatcher,
-        @message_queue,
-        range: start_line..end_line,
-      )
+      listener = Requests::SemanticHighlighting.new(dispatcher, range: start_line..end_line)
       dispatcher.visit(document.tree)
 
       Requests::Support::SemanticTokenEncoder.new.encode(listener.response)
@@ -474,34 +476,32 @@ module RubyLsp
     def completion(uri, position)
       document = @store.get(uri)
 
-      char_position = document.create_scanner.find_char_position(position)
-
-      # When the user types in the first letter of a constant name, we actually receive the position of the next
-      # immediate character. We check to see if the character is uppercase and then remove the offset to try to locate
-      # the node, as it could not be a constant
-      target_node_types = if ("A".."Z").cover?(document.source[char_position - 1])
-        char_position -= 1
-        [Prism::ConstantReadNode, Prism::ConstantPathNode]
-      else
-        [Prism::CallNode]
-      end
-
-      matched, parent, nesting = document.locate(document.tree, char_position, node_types: target_node_types)
+      # Completion always receives the position immediately after the character that was just typed. Here we adjust it
+      # back by 1, so that we find the right node
+      char_position = document.create_scanner.find_char_position(position) - 1
+      matched, parent, nesting = document.locate(
+        document.tree,
+        char_position,
+        node_types: [Prism::CallNode, Prism::ConstantReadNode, Prism::ConstantPathNode],
+      )
       return unless matched && parent
 
       target = case matched
       when Prism::CallNode
         message = matched.message
-        return unless message == "require"
 
-        args = matched.arguments&.arguments
-        return if args.nil? || args.is_a?(Prism::ForwardingArgumentsNode)
+        if message == "require"
+          args = matched.arguments&.arguments
+          return if args.nil? || args.is_a?(Prism::ForwardingArgumentsNode)
 
-        argument = args.first
-        return unless argument.is_a?(Prism::StringNode)
-        return unless (argument.location.start_offset..argument.location.end_offset).cover?(char_position)
+          argument = args.first
+          return unless argument.is_a?(Prism::StringNode)
+          return unless (argument.location.start_offset..argument.location.end_offset).cover?(char_position)
 
-        argument
+          argument
+        else
+          matched
+        end
       when Prism::ConstantReadNode, Prism::ConstantPathNode
         if parent.is_a?(Prism::ConstantPathNode) && matched.is_a?(Prism::ConstantReadNode)
           parent
@@ -513,12 +513,7 @@ module RubyLsp
       return unless target
 
       dispatcher = Prism::Dispatcher.new
-      listener = Requests::Completion.new(
-        @index,
-        nesting,
-        dispatcher,
-        @message_queue,
-      )
+      listener = Requests::Completion.new(@index, nesting, dispatcher)
       dispatcher.dispatch_once(target)
       listener.response
     end
@@ -579,10 +574,13 @@ module RubyLsp
       # notification
     end
 
-    sig { params(options: T::Hash[Symbol, T.untyped]).returns(Interface::InitializeResult) }
+    sig { params(options: T::Hash[Symbol, T.untyped]).returns(T::Hash[Symbol, T.untyped]) }
     def initialize_request(options)
       @store.clear
 
+      workspace_uri = options.dig(:workspaceFolders, 0, :uri)
+      @store.workspace_uri = URI(workspace_uri) if workspace_uri
+
       encodings = options.dig(:capabilities, :general, :positionEncodings)
       @store.encoding = if encodings.nil? || encodings.empty?
         Constant::PositionEncodingKind::UTF16
@@ -680,7 +678,7 @@ module RubyLsp
       completion_provider = if enabled_features["completion"]
         Interface::CompletionOptions.new(
           resolve_provider: false,
-          trigger_characters: ["/", *"A".."Z"],
+          trigger_characters: ["/"],
           completion_item: {
             labelDetailsSupport: true,
           },
@@ -716,7 +714,7 @@ module RubyLsp
 
       begin_progress("indexing-progress", "Ruby LSP: indexing files")
 
-      Interface::InitializeResult.new(
+      {
         capabilities: Interface::ServerCapabilities.new(
           text_document_sync: Interface::TextDocumentSyncOptions.new(
             change: Constant::TextDocumentSyncKind::INCREMENTAL,
@@ -740,7 +738,12 @@ module RubyLsp
           definition_provider: enabled_features["definition"],
           workspace_symbol_provider: enabled_features["workspaceSymbol"],
         ),
-      )
+        serverInfo: {
+          name: "Ruby LSP",
+          version: VERSION,
+        },
+        formatter: @store.formatter,
+      }
     end
 
     sig { void }

data/lib/ruby_lsp/internal.rb

@@ -24,6 +24,10 @@ require "ruby_lsp/server"
 require "ruby_lsp/executor"
 require "ruby_lsp/requests"
 require "ruby_lsp/listener"
+require "ruby_lsp/document"
+require "ruby_lsp/ruby_document"
 require "ruby_lsp/store"
 require "ruby_lsp/addon"
 require "ruby_lsp/requests/support/rubocop_runner"
+
+Bundler.ui.level = :silent

data/lib/ruby_lsp/listener.rb

@@ -14,10 +14,9 @@ module RubyLsp
 
     abstract!
 
-    sig { params(dispatcher: Prism::Dispatcher, message_queue: Thread::Queue).void }
-    def initialize(dispatcher, message_queue)
+    sig { params(dispatcher: Prism::Dispatcher).void }
+    def initialize(dispatcher)
       @dispatcher = dispatcher
-      @message_queue = message_queue
     end
 
     sig { returns(ResponseType) }
@@ -43,8 +42,8 @@ module RubyLsp
     # When inheriting from ExtensibleListener, the `super` of constructor must be called **after** the subclass's own
     # ivars have been initialized. This is because the constructor of ExtensibleListener calls
     # `initialize_external_listener` which may depend on the subclass's ivars.
-    sig { params(dispatcher: Prism::Dispatcher, message_queue: Thread::Queue).void }
-    def initialize(dispatcher, message_queue)
+    sig { params(dispatcher: Prism::Dispatcher).void }
+    def initialize(dispatcher)
       super
       @response_merged = T.let(false, T::Boolean)
       @external_listeners = T.let(

data/lib/ruby_lsp/requests/code_action_resolve.rb

@@ -87,15 +87,19 @@ module RubyLsp
             :start,
             :line,
           ) && closest_node_loc.end_line - 1 >= source_range.dig(:end, :line)
-            indentation_line = closest_node_loc.start_line - 1
-            target_line = indentation_line
+            indentation_line_number = closest_node_loc.start_line - 1
+            target_line = indentation_line_number
           else
             target_line = closest_node_loc.end_line
-            indentation_line = closest_node_loc.end_line - 1
+            indentation_line_number = closest_node_loc.end_line - 1
           end
 
           lines = @document.source.lines
-          indentation = T.must(T.must(lines[indentation_line])[/\A */]).size
+
+          indentation_line = lines[indentation_line_number]
+          return Error::InvalidTargetRange unless indentation_line
+
+          indentation = T.must(indentation_line[/\A */]).size
 
           target_range = {
             start: { line: target_line, character: indentation },

data/lib/ruby_lsp/requests/code_lens.rb

@@ -47,16 +47,18 @@ module RubyLsp
       sig { override.returns(ResponseType) }
       attr_reader :_response
 
-      sig { params(uri: URI::Generic, dispatcher: Prism::Dispatcher, message_queue: Thread::Queue).void }
-      def initialize(uri, dispatcher, message_queue)
+      sig { params(uri: URI::Generic, dispatcher: Prism::Dispatcher).void }
+      def initialize(uri, dispatcher)
         @uri = T.let(uri, URI::Generic)
         @_response = T.let([], ResponseType)
         @path = T.let(uri.to_standardized_path, T.nilable(String))
         # visibility_stack is a stack of [current_visibility, previous_visibility]
         @visibility_stack = T.let([[:public, :public]], T::Array[T::Array[T.nilable(Symbol)]])
         @class_stack = T.let([], T::Array[String])
+        @group_id = T.let(1, Integer)
+        @group_id_stack = T.let([], T::Array[Integer])
 
-        super(dispatcher, message_queue)
+        super(dispatcher)
 
         dispatcher.register(
           self,
@@ -82,12 +84,16 @@ module RubyLsp
             kind: :group,
           )
         end
+
+        @group_id_stack.push(@group_id)
+        @group_id += 1
       end
 
       sig { params(node: Prism::ClassNode).void }
       def on_class_node_leave(node)
         @visibility_stack.pop
         @class_stack.pop
+        @group_id_stack.pop
       end
 
       sig { params(node: Prism::DefNode).void }
@@ -146,7 +152,7 @@ module RubyLsp
 
       sig { override.params(addon: Addon).returns(T.nilable(Listener[ResponseType])) }
       def initialize_external_listener(addon)
-        addon.create_code_lens_listener(@uri, @dispatcher, @message_queue)
+        addon.create_code_lens_listener(@uri, @dispatcher)
       end
 
       sig { override.params(other: Listener[ResponseType]).returns(T.self_type) }
@@ -174,12 +180,15 @@ module RubyLsp
           },
         ]
 
+        grouping_data = { group_id: @group_id_stack.last, kind: kind }
+        grouping_data[:id] = @group_id if kind == :group
+
         @_response << create_code_lens(
           node,
           title: "Run",
           command_name: "rubyLsp.runTest",
           arguments: arguments,
-          data: { type: "test", kind: kind },
+          data: { type: "test", **grouping_data },
         )
 
         @_response << create_code_lens(
@@ -187,7 +196,7 @@ module RubyLsp
           title: "Run In Terminal",
           command_name: "rubyLsp.runTestInTerminal",
           arguments: arguments,
-          data: { type: "test_in_terminal", kind: kind },
+          data: { type: "test_in_terminal", **grouping_data },
         )
 
         @_response << create_code_lens(
@@ -195,7 +204,7 @@ module RubyLsp
           title: "Debug",
           command_name: "rubyLsp.debugTest",
           arguments: arguments,
-          data: { type: "debug", kind: kind },
+          data: { type: "debug", **grouping_data },
         )
       end