ruby-lsp 0.12.5 → 0.13.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2cb6c373890a19400025a75be13971ff5e5e33772bd74a178784a035ba94c168
-  data.tar.gz: d52ad65673ea9f1dfde13cfa6beec0f8c860a75b7f08453238597d584227b56f
+  metadata.gz: 78df9c8d35fc18cea6fc06a0f679b48b69e3daaaf504d762d2f5ae4df9d99ad0
+  data.tar.gz: 3c251eed7939e81c5aa115d303b2876d3769c509ef0487b0faa26d1a2de79c50
 SHA512:
-  metadata.gz: ba64686636c26776797fc6e7e70156f4c7f304dbe27e98c73c2a60a7255ae7260159838d68c0364e98bc58d26c404118ad9e3d1cfe13766a2221cbc4d2ac6a7c
-  data.tar.gz: fcf587173133668739ddc639d913ce34877cc1c0d3451b2ddc49254940ef8ba49815cae57dce2c6de423d3d3fb0db1059f1b8d2d19cd9d1de3af72fb26819759
+  metadata.gz: af33b81309429318e7fe61dc4a2bd989328b8e9127097ab621eab162e61e1b2d93f1be1b192307d3b48f47659489343e093d92125e9c68895c40517803dba5ed
+  data.tar.gz: 6373eb77209eb865e29026fba603f4db8d3249949bcff7c0aee3f550569a7225c84b76d5872fd61a8798c0ef04da2d538b50b4d3045697ef40cc85336a2c715b

data/VERSION

@@ -1 +1 @@
-0.12.5
+0.13.1

data/exe/ruby-lsp-check

@@ -17,8 +17,6 @@ end
 $LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
 require "ruby_lsp/internal"
 
-RubyLsp::Addon.load_addons
-
 T::Utils.run_all_sig_blocks
 
 files = Dir.glob("#{Dir.pwd}/**/*.rb")
@@ -28,6 +26,7 @@ puts "Verifying that all automatic LSP requests execute successfully. This may t
 errors = {}
 store = RubyLsp::Store.new
 message_queue = Thread::Queue.new
+RubyLsp::Addon.load_addons(message_queue)
 executor = RubyLsp::Executor.new(store, message_queue)
 
 files.each_with_index do |file, index|
@@ -50,13 +49,30 @@ end
 puts "\n"
 message_queue.close
 
+# Indexing
+puts "Verifying that indexing executes successfully. This may take a while..."
+
+index = RubyIndexer::Index.new
+indexables = RubyIndexer.configuration.indexables
+
+indexables.each_with_index do |indexable, i|
+  result = Prism.parse(File.read(indexable.full_path))
+  collector = RubyIndexer::Collector.new(index, result, indexable.full_path)
+  collector.collect(result.value)
+rescue => e
+  errors[indexable.full_path] = e
+ensure
+  print("\033[M\033[0KIndexed #{i + 1}/#{indexables.length}") unless ENV["CI"]
+end
+puts "\n"
+
 if errors.empty?
-  puts "All automatic LSP requests executed successfully"
+  puts "All operations completed successfully!"
   exit
 end
 
 puts <<~ERRORS
-  Errors while executing requests:
+  Errors while executing:
 
   #{errors.map { |file, error| "#{file}: #{error.message}" }.join("\n")}
 ERRORS

data/lib/ruby_indexer/lib/ruby_indexer/collector.rb

@@ -141,8 +141,18 @@ module RubyIndexer
 
     sig { params(node: Prism::CallNode).void }
     def handle_call_node(node)
-      message = node.message
-      handle_private_constant(node) if message == "private_constant"
+      message = node.name
+
+      case message
+      when :private_constant
+        handle_private_constant(node)
+      when :attr_reader
+        handle_attribute(node, reader: true, writer: false)
+      when :attr_writer
+        handle_attribute(node, reader: false, writer: true)
+      when :attr_accessor
+        handle_attribute(node, reader: true, writer: true)
+      end
     end
 
     sig { params(node: Prism::DefNode).void }
@@ -312,5 +322,29 @@ module RubyIndexer
         "#{@stack.join("::")}::#{name}"
       end.delete_prefix("::")
     end
+
+    sig { params(node: Prism::CallNode, reader: T::Boolean, writer: T::Boolean).void }
+    def handle_attribute(node, reader:, writer:)
+      arguments = node.arguments&.arguments
+      return unless arguments
+
+      receiver = node.receiver
+      return unless receiver.nil? || receiver.is_a?(Prism::SelfNode)
+
+      comments = collect_comments(node)
+      arguments.each do |argument|
+        name, loc = case argument
+        when Prism::SymbolNode
+          [argument.value, argument.value_loc]
+        when Prism::StringNode
+          [argument.content, argument.content_loc]
+        end
+
+        next unless name && loc
+
+        @index << Entry::Accessor.new(name, @file_path, loc, comments, @current_owner) if reader
+        @index << Entry::Accessor.new("#{name}=", @file_path, loc, comments, @current_owner) if writer
+      end
+    end
   end
 end

data/lib/ruby_indexer/lib/ruby_indexer/configuration.rb

@@ -120,7 +120,7 @@ module RubyIndexer
               IndexablePath.new(RbConfig::CONFIG["rubylibdir"], path)
             end,
           )
-        else
+        elsif pathname.extname == ".rb"
           # If the default_path is a Ruby file, we index it
           indexables << IndexablePath.new(RbConfig::CONFIG["rubylibdir"], default_path)
         end

data/lib/ruby_indexer/lib/ruby_indexer/entry.rb

@@ -90,20 +90,84 @@ module RubyIndexer
       end
     end
 
+    # A required method parameter, e.g. `def foo(a)`
     class RequiredParameter < Parameter
     end
 
-    class Method < Entry
+    # An optional method parameter, e.g. `def foo(a = 123)`
+    class OptionalParameter < Parameter
+    end
+
+    # An required keyword method parameter, e.g. `def foo(a:)`
+    class KeywordParameter < Parameter
+    end
+
+    # An optional keyword method parameter, e.g. `def foo(a: 123)`
+    class OptionalKeywordParameter < Parameter
+    end
+
+    # A rest method parameter, e.g. `def foo(*a)`
+    class RestParameter < Parameter
+      DEFAULT_NAME = T.let(:"<anonymous splat>", Symbol)
+    end
+
+    # A keyword rest method parameter, e.g. `def foo(**a)`
+    class KeywordRestParameter < Parameter
+      DEFAULT_NAME = T.let(:"<anonymous keyword splat>", Symbol)
+    end
+
+    # A block method parameter, e.g. `def foo(&block)`
+    class BlockParameter < Parameter
+      DEFAULT_NAME = T.let(:"<anonymous block>", Symbol)
+    end
+
+    class Member < Entry
       extend T::Sig
       extend T::Helpers
-      abstract!
 
-      sig { returns(T::Array[Parameter]) }
-      attr_reader :parameters
+      abstract!
 
       sig { returns(T.nilable(Entry::Namespace)) }
       attr_reader :owner
 
+      sig do
+        params(
+          name: String,
+          file_path: String,
+          location: Prism::Location,
+          comments: T::Array[String],
+          owner: T.nilable(Entry::Namespace),
+        ).void
+      end
+      def initialize(name, file_path, location, comments, owner)
+        super(name, file_path, location, comments)
+        @owner = owner
+      end
+
+      sig { abstract.returns(T::Array[Parameter]) }
+      def parameters; end
+    end
+
+    class Accessor < Member
+      extend T::Sig
+
+      sig { override.returns(T::Array[Parameter]) }
+      def parameters
+        params = []
+        params << RequiredParameter.new(name: name.delete_suffix("=").to_sym) if name.end_with?("=")
+        params
+      end
+    end
+
+    class Method < Member
+      extend T::Sig
+      extend T::Helpers
+
+      abstract!
+
+      sig { override.returns(T::Array[Parameter]) }
+      attr_reader :parameters
+
       sig do
         params(
           name: String,
@@ -115,9 +179,9 @@ module RubyIndexer
         ).void
       end
       def initialize(name, file_path, location, comments, parameters_node, owner) # rubocop:disable Metrics/ParameterLists
-        super(name, file_path, location, comments)
+        super(name, file_path, location, comments, owner)
+
         @parameters = T.let(list_params(parameters_node), T::Array[Parameter])
-        @owner = owner
       end
 
       private
@@ -126,23 +190,78 @@ module RubyIndexer
       def list_params(parameters_node)
         return [] unless parameters_node
 
-        parameters_node.requireds.filter_map do |required|
+        parameters = []
+
+        parameters_node.requireds.each do |required|
           name = parameter_name(required)
           next unless name
 
-          RequiredParameter.new(name: name)
+          parameters << RequiredParameter.new(name: name)
         end
-      end
 
-      sig do
-        params(node: Prism::Node).returns(T.nilable(Symbol))
+        parameters_node.optionals.each do |optional|
+          name = parameter_name(optional)
+          next unless name
+
+          parameters << OptionalParameter.new(name: name)
+        end
+
+        parameters_node.keywords.each do |keyword|
+          name = parameter_name(keyword)
+          next unless name
+
+          case keyword
+          when Prism::RequiredKeywordParameterNode
+            parameters << KeywordParameter.new(name: name)
+          when Prism::OptionalKeywordParameterNode
+            parameters << OptionalKeywordParameter.new(name: name)
+          end
+        end
+
+        rest = parameters_node.rest
+
+        if rest
+          rest_name = rest.name || RestParameter::DEFAULT_NAME
+          parameters << RestParameter.new(name: rest_name)
+        end
+
+        keyword_rest = parameters_node.keyword_rest
+
+        if keyword_rest.is_a?(Prism::KeywordRestParameterNode)
+          keyword_rest_name = parameter_name(keyword_rest) || KeywordRestParameter::DEFAULT_NAME
+          parameters << KeywordRestParameter.new(name: keyword_rest_name)
+        end
+
+        parameters_node.posts.each do |post|
+          name = parameter_name(post)
+          next unless name
+
+          parameters << RequiredParameter.new(name: name)
+        end
+
+        block = parameters_node.block
+        parameters << BlockParameter.new(name: block.name || BlockParameter::DEFAULT_NAME) if block
+
+        parameters
       end
+
+      sig { params(node: T.nilable(Prism::Node)).returns(T.nilable(Symbol)) }
       def parameter_name(node)
         case node
-        when Prism::RequiredParameterNode
+        when Prism::RequiredParameterNode, Prism::OptionalParameterNode,
+          Prism::RequiredKeywordParameterNode, Prism::OptionalKeywordParameterNode,
+          Prism::RestParameterNode, Prism::KeywordRestParameterNode
           node.name
         when Prism::MultiTargetNode
-          names = [*node.lefts, *node.rest, *node.rights].map { |parameter_node| parameter_name(parameter_node) }
+          names = node.lefts.map { |parameter_node| parameter_name(parameter_node) }
+
+          rest = node.rest
+          if rest.is_a?(Prism::SplatNode)
+            name = rest.expression&.slice
+            names << (rest.operator == "*" ? "*#{name}".to_sym : name&.to_sym)
+          end
+
+          names.concat(node.rights.map { |parameter_node| parameter_name(parameter_node) })
 
           names_with_commas = names.join(", ")
           :"(#{names_with_commas})"

data/lib/ruby_indexer/test/configuration_test.rb

@@ -84,6 +84,16 @@ module RubyIndexer
       )
     end
 
+    def test_indexables_does_not_include_non_ruby_files_inside_rubylibdir
+      path = Pathname.new(RbConfig::CONFIG["rubylibdir"]).join("extra_file.txt").to_s
+      FileUtils.touch(path)
+      indexables = @config.indexables
+
+      assert(indexables.none? { |indexable| indexable.full_path == path })
+    ensure
+      FileUtils.rm(T.must(path))
+    end
+
     def test_paths_are_unique
       @config.load_config
       indexables = @config.indexables

data/lib/ruby_indexer/test/index_test.rb

@@ -246,5 +246,16 @@ module RubyIndexer
       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

@@ -70,6 +70,178 @@ module RubyIndexer
       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_method_with_rest_and_keyword_rest_parameters
+      index(<<~RUBY)
+        class Foo
+          def bar(*a, **b)
+          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::RestParameter, a)
+
+      assert_equal(:b, b.name)
+      assert_instance_of(Entry::KeywordRestParameter, b)
+    end
+
+    def test_method_with_post_parameters
+      index(<<~RUBY)
+        class Foo
+          def bar(*a, b)
+          end
+
+          def baz(**a, b)
+          end
+
+          def qux(*a, (b, c))
+        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::RestParameter, a)
+
+      assert_equal(:b, b.name)
+      assert_instance_of(Entry::RequiredParameter, b)
+
+      entry = T.must(@index["baz"].first)
+      assert_equal(2, entry.parameters.length)
+      a, b = entry.parameters
+
+      assert_equal(:a, a.name)
+      assert_instance_of(Entry::KeywordRestParameter, a)
+
+      assert_equal(:b, b.name)
+      assert_instance_of(Entry::RequiredParameter, b)
+
+      entry = T.must(@index["qux"].first)
+      assert_equal(2, entry.parameters.length)
+      _a, second = entry.parameters
+
+      assert_equal(:"(b, c)", second.name)
+      assert_instance_of(Entry::RequiredParameter, second)
+    end
+
+    def test_method_with_destructured_rest_parameters
+      index(<<~RUBY)
+        class Foo
+          def bar((a, *b))
+          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)
+      param = entry.parameters.first
+
+      assert_equal(:"(a, *b)", param.name)
+      assert_instance_of(Entry::RequiredParameter, param)
+    end
+
+    def test_method_with_block_parameters
+      index(<<~RUBY)
+        class Foo
+          def bar(&block)
+          end
+
+          def baz(&)
+          end
+        end
+      RUBY
+
+      entry = T.must(@index["bar"].first)
+      param = entry.parameters.first
+      assert_equal(:block, param.name)
+      assert_instance_of(Entry::BlockParameter, param)
+
+      entry = T.must(@index["baz"].first)
+      assert_equal(1, entry.parameters.length)
+
+      param = entry.parameters.first
+      assert_equal(Entry::BlockParameter::DEFAULT_NAME, param.name)
+      assert_instance_of(Entry::BlockParameter, param)
+    end
+
+    def test_method_with_anonymous_rest_parameters
+      index(<<~RUBY)
+        class Foo
+          def bar(*, **)
+          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)
+      first, second = entry.parameters
+
+      assert_equal(Entry::RestParameter::DEFAULT_NAME, first.name)
+      assert_instance_of(Entry::RestParameter, first)
+
+      assert_equal(Entry::KeywordRestParameter::DEFAULT_NAME, second.name)
+      assert_instance_of(Entry::KeywordRestParameter, second)
+    end
+
+    def test_method_with_forbidden_keyword_splat_parameter
+      index(<<~RUBY)
+        class Foo
+          def bar(**nil)
+          end
+        end
+      RUBY
+
+      assert_entry("bar", Entry::InstanceMethod, "/fake/path/foo.rb:1-2:2-5")
+      entry = T.must(@index["bar"].first)
+      assert_empty(entry.parameters)
+    end
+
     def test_keeps_track_of_method_owner
       index(<<~RUBY)
         class Foo
@@ -83,5 +255,35 @@ module RubyIndexer
 
       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

@@ -24,6 +24,9 @@ module RubyLsp
     sig { returns(URI::Generic) }
     attr_reader :uri
 
+    sig { returns(String) }
+    attr_reader :encoding
+
     sig { params(source: String, version: Integer, uri: URI::Generic, encoding: String).void }
     def initialize(source:, version:, uri:, encoding: Constant::PositionEncodingKind::UTF8)
       @cache = T.let({}, T::Hash[String, T.untyped])