ruby-lsp 0.17.4 → 0.17.13

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

@@ -15,62 +15,65 @@ module RubyIndexer
       loader = RBS::EnvironmentLoader.new
       RBS::Environment.from_loader(loader).resolve_type_names
 
-      loader.each_signature do |source, pathname, _buffer, declarations, _directives|
-        process_signature(source, pathname, declarations)
+      loader.each_signature do |_source, pathname, _buffer, declarations, _directives|
+        process_signature(pathname, declarations)
       end
     end
 
-    private
-
-    sig { params(source: T.untyped, pathname: Pathname, declarations: T::Array[RBS::AST::Declarations::Base]).void }
-    def process_signature(source, pathname, declarations)
+    sig do
+      params(
+        pathname: Pathname,
+        declarations: T::Array[RBS::AST::Declarations::Base],
+      ).void
+    end
+    def process_signature(pathname, declarations)
       declarations.each do |declaration|
         process_declaration(declaration, pathname)
       end
     end
 
+    private
+
     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)
+      when RBS::AST::Declarations::Constant
+        namespace_nesting = declaration.name.namespace.path.map(&:to_s)
+        handle_constant(declaration, namespace_nesting, pathname.to_s)
       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, 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, comments)
-      add_declaration_mixins_to_entry(declaration, module_entry)
-      @index.add(module_entry)
+      comments = comments_to_string(declaration)
+      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)
+        case member
+        when RBS::AST::Members::MethodDefinition
+          handle_method(member, entry)
+        when RBS::AST::Declarations::Constant
+          handle_constant(member, nesting, file_path)
+        when RBS::AST::Members::Alias
+          # In RBS, an alias means that two methods have the same signature.
+          # It does not mean the same thing as a Ruby alias.
+          handle_signature_alias(member, entry)
+        end
       end
     end
 
@@ -93,16 +96,15 @@ module RubyIndexer
     def add_declaration_mixins_to_entry(declaration, entry)
       declaration.each_mixin do |mixin|
         name = mixin.name.name.to_s
-        mixin_operation =
-          case mixin
-          when RBS::AST::Members::Include
-            Entry::Include.new(name)
-          when RBS::AST::Members::Extend
-            Entry::Extend.new(name)
-          when RBS::AST::Members::Prepend
-            Entry::Prepend.new(name)
-          end
-        entry.mixin_operations << mixin_operation if mixin_operation
+        case mixin
+        when RBS::AST::Members::Include
+          entry.mixin_operations << Entry::Include.new(name)
+        when RBS::AST::Members::Prepend
+          entry.mixin_operations << Entry::Prepend.new(name)
+        when RBS::AST::Members::Extend
+          singleton = @index.existing_or_new_singleton_class(entry.name)
+          singleton.mixin_operations << Entry::Include.new(name)
+        end
       end
     end
 
@@ -111,7 +113,7 @@ module RubyIndexer
       name = member.name.name
       file_path = member.location.buffer.name
       location = to_ruby_indexer_location(member.location)
-      comments = Array(member.comment&.string)
+      comments = comments_to_string(member)
 
       visibility = case member.visibility
       when :private
@@ -122,26 +124,158 @@ module RubyIndexer
         Entry::Visibility::PUBLIC
       end
 
-      real_owner = member.singleton? ? existing_or_new_singleton_klass(owner) : owner
-      @index.add(Entry::Method.new(name, file_path, location, comments, [], visibility, real_owner))
+      real_owner = member.singleton? ? @index.existing_or_new_singleton_class(owner.name) : owner
+      signatures = signatures(member)
+      @index.add(Entry::Method.new(name, file_path, location, location, comments, signatures, visibility, real_owner))
+    end
+
+    sig { params(member: RBS::AST::Members::MethodDefinition).returns(T::Array[Entry::Signature]) }
+    def signatures(member)
+      member.overloads.map do |overload|
+        parameters = process_overload(overload)
+        Entry::Signature.new(parameters)
+      end
     end
 
-    sig { params(owner: Entry::Namespace).returns(T.nilable(Entry::Class)) }
-    def existing_or_new_singleton_klass(owner)
-      *_parts, name = owner.name.split("::")
+    sig { params(overload: RBS::AST::Members::MethodDefinition::Overload).returns(T::Array[Entry::Parameter]) }
+    def process_overload(overload)
+      function = T.cast(overload.method_type.type, RBS::Types::Function)
+      parameters = parse_arguments(function)
+
+      block = overload.method_type.block
+      parameters << Entry::BlockParameter.anonymous if block&.required
+
+      parameters
+    end
+
+    sig { params(function: RBS::Types::Function).returns(T::Array[Entry::Parameter]) }
+    def parse_arguments(function)
+      parameters = []
+      parameters.concat(process_required_and_optional_positionals(function))
+      parameters.concat(process_trailing_positionals(function)) if function.trailing_positionals
+      parameters << process_rest_positionals(function) if function.rest_positionals
+      parameters.concat(process_required_keywords(function)) if function.required_keywords
+      parameters.concat(process_optional_keywords(function)) if function.optional_keywords
+      parameters << process_rest_keywords(function) if function.rest_keywords
+      parameters
+    end
+
+    sig { params(function: RBS::Types::Function).returns(T::Array[Entry::RequiredParameter]) }
+    def process_required_and_optional_positionals(function)
+      argument_offset = 0
+
+      required = function.required_positionals.map.with_index(argument_offset) do |param, i|
+        # Some parameters don't have names, e.g.
+        #   def self.try_convert: [U] (untyped) -> ::Array[U]?
+        name = param.name || :"arg#{i}"
+        argument_offset += 1
+
+        Entry::RequiredParameter.new(name: name)
+      end
 
-      # Return the existing singleton class if available
-      singleton_entries = T.cast(
-        @index["#{owner.name}::<Class:#{name}>"],
-        T.nilable(T::Array[Entry::SingletonClass]),
+      optional = function.optional_positionals.map.with_index(argument_offset) do |param, i|
+        # Optional positionals may be unnamed, e.g.
+        #  def self.polar: (Numeric, ?Numeric) -> Complex
+        name = param.name || :"arg#{i}"
+
+        Entry::OptionalParameter.new(name: name)
+      end
+
+      required + optional
+    end
+
+    sig { params(function: RBS::Types::Function).returns(T::Array[Entry::OptionalParameter]) }
+    def process_trailing_positionals(function)
+      function.trailing_positionals.map do |param|
+        Entry::OptionalParameter.new(name: param.name)
+      end
+    end
+
+    sig { params(function: RBS::Types::Function).returns(Entry::RestParameter) }
+    def process_rest_positionals(function)
+      rest = function.rest_positionals
+
+      rest_name = rest.name || Entry::RestParameter::DEFAULT_NAME
+
+      Entry::RestParameter.new(name: rest_name)
+    end
+
+    sig { params(function: RBS::Types::Function).returns(T::Array[Entry::KeywordParameter]) }
+    def process_required_keywords(function)
+      function.required_keywords.map do |name, _param|
+        Entry::KeywordParameter.new(name: name)
+      end
+    end
+
+    sig { params(function: RBS::Types::Function).returns(T::Array[Entry::OptionalKeywordParameter]) }
+    def process_optional_keywords(function)
+      function.optional_keywords.map do |name, _param|
+        Entry::OptionalKeywordParameter.new(name: name)
+      end
+    end
+
+    sig { params(function: RBS::Types::Function).returns(Entry::KeywordRestParameter) }
+    def process_rest_keywords(function)
+      param = function.rest_keywords
+
+      name = param.name || Entry::KeywordRestParameter::DEFAULT_NAME
+
+      Entry::KeywordRestParameter.new(name: name)
+    end
+
+    # RBS treats constant definitions differently depend on where they are defined.
+    # When constants' rbs are defined inside a class/module block, they are treated as
+    # members of the class/module.
+    #
+    # module Encoding
+    #   US_ASCII = ... # US_ASCII is a member of Encoding
+    # end
+    #
+    # When constants' rbs are defined outside a class/module block, they are treated as
+    # top-level constants.
+    #
+    # Complex::I = ... # Complex::I is a top-level constant
+    #
+    # And we need to handle their nesting differently.
+    sig { params(declaration: RBS::AST::Declarations::Constant, nesting: T::Array[String], file_path: String).void }
+    def handle_constant(declaration, nesting, file_path)
+      fully_qualified_name = [*nesting, declaration.name.name.to_s].join("::")
+      @index.add(Entry::Constant.new(
+        fully_qualified_name,
+        file_path,
+        to_ruby_indexer_location(declaration.location),
+        comments_to_string(declaration),
+      ))
+    end
+
+    sig { params(member: RBS::AST::Members::Alias, owner_entry: Entry::Namespace).void }
+    def handle_signature_alias(member, owner_entry)
+      file_path = member.location.buffer.name
+      comments = comments_to_string(member)
+
+      entry = Entry::UnresolvedMethodAlias.new(
+        member.new_name.to_s,
+        member.old_name.to_s,
+        owner_entry,
+        file_path,
+        to_ruby_indexer_location(member.location),
+        comments,
       )
-      return singleton_entries.first if singleton_entries
 
-      # If not available, create the singleton class lazily
-      nesting = owner.nesting + ["<Class:#{name}>"]
-      entry = Entry::SingletonClass.new(nesting, owner.file_path, owner.location, [], nil)
-      @index.add(entry, skip_prefix_tree: true)
-      entry
+      @index.add(entry)
+    end
+
+    sig do
+      params(declaration: T.any(
+        RBS::AST::Declarations::Class,
+        RBS::AST::Declarations::Module,
+        RBS::AST::Declarations::Constant,
+        RBS::AST::Members::MethodDefinition,
+        RBS::AST::Members::Alias,
+      )).returns(T::Array[String])
+    end
+    def comments_to_string(declaration)
+      Array(declaration.comment&.string)
     end
   end
 end

data/lib/ruby_indexer/ruby_indexer.rb

@@ -6,6 +6,7 @@ require "did_you_mean"
 
 require "ruby_indexer/lib/ruby_indexer/indexable_path"
 require "ruby_indexer/lib/ruby_indexer/declaration_listener"
+require "ruby_indexer/lib/ruby_indexer/enhancement"
 require "ruby_indexer/lib/ruby_indexer/index"
 require "ruby_indexer/lib/ruby_indexer/entry"
 require "ruby_indexer/lib/ruby_indexer/configuration"
@@ -14,12 +15,4 @@ require "ruby_indexer/lib/ruby_indexer/location"
 require "ruby_indexer/lib/ruby_indexer/rbs_indexer"
 
 module RubyIndexer
-  @configuration = T.let(Configuration.new, Configuration)
-
-  class << self
-    extend T::Sig
-
-    sig { returns(Configuration) }
-    attr_reader :configuration
-  end
 end

data/lib/ruby_indexer/test/classes_and_modules_test.rb

@@ -461,13 +461,13 @@ module RubyIndexer
         end
       RUBY
 
-      foo = T.must(@index["Foo"][0])
+      foo = T.must(@index["Foo::<Class:Foo>"][0])
       assert_equal(["A1", "A2", "A3", "A4", "A5", "A6"], foo.mixin_operation_module_names)
 
-      qux = T.must(@index["Foo::Qux"][0])
+      qux = T.must(@index["Foo::Qux::<Class:Qux>"][0])
       assert_equal(["Corge", "Corge", "Baz"], qux.mixin_operation_module_names)
 
-      constant_path_references = T.must(@index["ConstantPathReferences"][0])
+      constant_path_references = T.must(@index["ConstantPathReferences::<Class:ConstantPathReferences>"][0])
       assert_equal(["Foo::Bar", "Foo::Bar2"], constant_path_references.mixin_operation_module_names)
     end
 
@@ -516,5 +516,73 @@ module RubyIndexer
 
       assert_entry("Foo::<Class:Foo>::Bar", Entry::Class, "/fake/path/foo.rb:2-4:3-7")
     end
+
+    def test_name_location_points_to_constant_path_location
+      index(<<~RUBY)
+        class Foo
+          def foo; end
+        end
+
+        module Bar
+          def bar; end
+        end
+      RUBY
+
+      foo = T.must(@index["Foo"].first)
+      refute_equal(foo.location, foo.name_location)
+
+      name_location = foo.name_location
+      assert_equal(1, name_location.start_line)
+      assert_equal(1, name_location.end_line)
+      assert_equal(6, name_location.start_column)
+      assert_equal(9, name_location.end_column)
+
+      bar = T.must(@index["Bar"].first)
+      refute_equal(bar.location, bar.name_location)
+
+      name_location = bar.name_location
+      assert_equal(5, name_location.start_line)
+      assert_equal(5, name_location.end_line)
+      assert_equal(7, name_location.start_column)
+      assert_equal(10, name_location.end_column)
+    end
+
+    def test_indexing_namespaces_inside_top_level_references
+      index(<<~RUBY)
+        module ::Foo
+          class Bar
+          end
+        end
+      RUBY
+
+      # We want to explicitly verify that we didn't introduce the leading `::` by accident, but `Index#[]` deletes the
+      # prefix when we use `refute_entry`
+      entries = @index.instance_variable_get(:@entries)
+      refute(entries.key?("::Foo"))
+      refute(entries.key?("::Foo::Bar"))
+      assert_entry("Foo", Entry::Module, "/fake/path/foo.rb:0-0:3-3")
+      assert_entry("Foo::Bar", Entry::Class, "/fake/path/foo.rb:1-2:2-5")
+    end
+
+    def test_indexing_namespaces_inside_nested_top_level_references
+      index(<<~RUBY)
+        class Baz
+          module ::Foo
+            class Bar
+            end
+
+            class ::Qux
+            end
+          end
+        end
+      RUBY
+
+      refute_entry("Baz::Foo")
+      refute_entry("Baz::Foo::Bar")
+      assert_entry("Baz", Entry::Class, "/fake/path/foo.rb:0-0:8-3")
+      assert_entry("Foo", Entry::Module, "/fake/path/foo.rb:1-2:7-5")
+      assert_entry("Foo::Bar", Entry::Class, "/fake/path/foo.rb:2-4:3-7")
+      assert_entry("Qux", Entry::Class, "/fake/path/foo.rb:5-4:6-7")
+    end
   end
 end

data/lib/ruby_indexer/test/configuration_test.rb

@@ -108,7 +108,7 @@ module RubyIndexer
     end
 
     def test_magic_comments_regex
-      regex = RubyIndexer.configuration.magic_comment_regex
+      regex = @config.magic_comment_regex
 
       [
         "# frozen_string_literal:",

data/lib/ruby_indexer/test/constant_test.rb

@@ -200,12 +200,12 @@ module RubyIndexer
       RUBY
 
       unresolve_entry = @index["A::FIRST"].first
-      assert_instance_of(Entry::UnresolvedAlias, unresolve_entry)
+      assert_instance_of(Entry::UnresolvedConstantAlias, unresolve_entry)
       assert_equal(["A"], unresolve_entry.nesting)
       assert_equal("B::C", unresolve_entry.target)
 
       resolved_entry = @index.resolve("A::FIRST", []).first
-      assert_instance_of(Entry::Alias, resolved_entry)
+      assert_instance_of(Entry::ConstantAlias, resolved_entry)
       assert_equal("A::B::C", resolved_entry.target)
     end
 
@@ -226,12 +226,12 @@ module RubyIndexer
       RUBY
 
       unresolve_entry = @index["A::ALIAS"].first
-      assert_instance_of(Entry::UnresolvedAlias, unresolve_entry)
+      assert_instance_of(Entry::UnresolvedConstantAlias, unresolve_entry)
       assert_equal(["A"], unresolve_entry.nesting)
       assert_equal("B", unresolve_entry.target)
 
       resolved_entry = @index.resolve("ALIAS", ["A"]).first
-      assert_instance_of(Entry::Alias, resolved_entry)
+      assert_instance_of(Entry::ConstantAlias, resolved_entry)
       assert_equal("A::B", resolved_entry.target)
 
       resolved_entry = @index.resolve("ALIAS::C", ["A"]).first
@@ -239,7 +239,7 @@ module RubyIndexer
       assert_equal("A::B::C", resolved_entry.name)
 
       unresolve_entry = @index["Other::ONE_MORE"].first
-      assert_instance_of(Entry::UnresolvedAlias, unresolve_entry)
+      assert_instance_of(Entry::UnresolvedConstantAlias, unresolve_entry)
       assert_equal(["Other"], unresolve_entry.nesting)
       assert_equal("A::ALIAS", unresolve_entry.target)
 
@@ -259,12 +259,12 @@ module RubyIndexer
 
       # B and C
       unresolve_entry = @index["A::B"].first
-      assert_instance_of(Entry::UnresolvedAlias, unresolve_entry)
+      assert_instance_of(Entry::UnresolvedConstantAlias, unresolve_entry)
       assert_equal(["A"], unresolve_entry.nesting)
       assert_equal("C", unresolve_entry.target)
 
       resolved_entry = @index.resolve("A::B", []).first
-      assert_instance_of(Entry::Alias, resolved_entry)
+      assert_instance_of(Entry::ConstantAlias, resolved_entry)
       assert_equal("A::C", resolved_entry.target)
 
       constant = @index["A::C"].first
@@ -272,38 +272,38 @@ module RubyIndexer
 
       # D and E
       unresolve_entry = @index["A::D"].first
-      assert_instance_of(Entry::UnresolvedAlias, unresolve_entry)
+      assert_instance_of(Entry::UnresolvedConstantAlias, unresolve_entry)
       assert_equal(["A"], unresolve_entry.nesting)
       assert_equal("E", unresolve_entry.target)
 
       resolved_entry = @index.resolve("A::D", []).first
-      assert_instance_of(Entry::Alias, resolved_entry)
+      assert_instance_of(Entry::ConstantAlias, resolved_entry)
       assert_equal("A::E", resolved_entry.target)
 
       # F and G::H
       unresolve_entry = @index["A::F"].first
-      assert_instance_of(Entry::UnresolvedAlias, unresolve_entry)
+      assert_instance_of(Entry::UnresolvedConstantAlias, unresolve_entry)
       assert_equal(["A"], unresolve_entry.nesting)
       assert_equal("G::H", unresolve_entry.target)
 
       resolved_entry = @index.resolve("A::F", []).first
-      assert_instance_of(Entry::Alias, resolved_entry)
+      assert_instance_of(Entry::ConstantAlias, resolved_entry)
       assert_equal("A::G::H", resolved_entry.target)
 
       # I::J, K::L and M
       unresolve_entry = @index["A::I::J"].first
-      assert_instance_of(Entry::UnresolvedAlias, unresolve_entry)
+      assert_instance_of(Entry::UnresolvedConstantAlias, unresolve_entry)
       assert_equal(["A"], unresolve_entry.nesting)
       assert_equal("K::L", unresolve_entry.target)
 
       resolved_entry = @index.resolve("A::I::J", []).first
-      assert_instance_of(Entry::Alias, resolved_entry)
+      assert_instance_of(Entry::ConstantAlias, resolved_entry)
       assert_equal("A::K::L", resolved_entry.target)
 
       # When we are resolving A::I::J, we invoke `resolve("K::L", ["A"])`, which recursively resolves A::K::L too.
       # Therefore, both A::I::J and A::K::L point to A::M by the end of the previous resolve invocation
       resolved_entry = @index["A::K::L"].first
-      assert_instance_of(Entry::Alias, resolved_entry)
+      assert_instance_of(Entry::ConstantAlias, resolved_entry)
       assert_equal("A::M", resolved_entry.target)
 
       constant = @index["A::M"].first
@@ -344,11 +344,11 @@ module RubyIndexer
       RUBY
 
       assert_entry("A::B", Entry::Constant, "/fake/path/foo.rb:1-2:1-3")
-      assert_entry("A::C", Entry::UnresolvedAlias, "/fake/path/foo.rb:1-5:1-6")
-      assert_entry("A::D::E", Entry::UnresolvedAlias, "/fake/path/foo.rb:2-2:2-6")
+      assert_entry("A::C", Entry::UnresolvedConstantAlias, "/fake/path/foo.rb:1-5:1-6")
+      assert_entry("A::D::E", Entry::UnresolvedConstantAlias, "/fake/path/foo.rb:2-2:2-6")
       assert_entry("A::F::G", Entry::Constant, "/fake/path/foo.rb:2-8:2-12")
       assert_entry("A::H", Entry::Constant, "/fake/path/foo.rb:3-2:3-3")
-      assert_entry("A::I::J", Entry::UnresolvedAlias, "/fake/path/foo.rb:3-5:3-9")
+      assert_entry("A::I::J", Entry::UnresolvedConstantAlias, "/fake/path/foo.rb:3-5:3-9")
       assert_entry("A::K", Entry::Constant, "/fake/path/foo.rb:4-2:4-3")
       assert_entry("A::L", Entry::Constant, "/fake/path/foo.rb:4-5:4-6")
     end