ruby-lsp 0.17.4 → 0.17.5

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

@@ -150,17 +150,42 @@ module RubyIndexer
       ancestors = linearized_ancestors_of(receiver_name)
 
       candidates = name ? prefix_search(name).flatten : @entries.values.flatten
-      candidates.filter_map do |entry|
-        case entry
-        when Entry::Member, Entry::MethodAlias
-          entry if ancestors.any?(entry.owner&.name)
-        when Entry::UnresolvedMethodAlias
-          if ancestors.any?(entry.owner&.name)
-            resolved_alias = resolve_method_alias(entry, receiver_name)
-            resolved_alias if resolved_alias.is_a?(Entry::MethodAlias)
-          end
+      completion_items = candidates.each_with_object({}) do |entry, hash|
+        unless entry.is_a?(Entry::Member) || entry.is_a?(Entry::MethodAlias) ||
+            entry.is_a?(Entry::UnresolvedMethodAlias)
+          next
+        end
+
+        entry_name = entry.name
+        ancestor_index = ancestors.index(entry.owner&.name)
+        existing_entry, existing_entry_index = hash[entry_name]
+
+        # Conditions for matching a method completion candidate:
+        # 1. If an ancestor_index was found, it means that this method is owned by the receiver. The exact index is
+        # where in the ancestor chain the method was found. For example, if the ancestors are ["A", "B", "C"] and we
+        # found the method declared in `B`, then the ancestors index is 1
+        #
+        # 2. We already established that this method is owned by the receiver. Now, check if we already added a
+        # completion candidate for this method name. If not, then we just go and add it (the left hand side of the or)
+        #
+        # 3. If we had already found a method entry for the same name, then we need to check if the current entry that
+        # we are comparing appears first in the hierarchy or not. For example, imagine we have the method `open` defined
+        # in both `File` and its parent `IO`. If we first find the method `open` in `IO`, it will be inserted into the
+        # hash. Then, when we find the entry for `open` owned by `File`, we need to replace `IO.open` by `File.open`,
+        # since `File.open` appears first in the hierarchy chain and is therefore the correct method being invoked. The
+        # last part of the conditional checks if the current entry was found earlier in the hierarchy chain, in which
+        # case we must update the existing entry to avoid showing the wrong method declaration for overridden methods
+        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)
+          hash[entry_name] = [resolved_alias, ancestor_index] if resolved_alias.is_a?(Entry::MethodAlias)
+        else
+          hash[entry_name] = [entry, ancestor_index]
         end
       end
+
+      completion_items.values.map!(&:first)
     end
 
     # Resolve a constant to its declaration based on its name and the nesting where the reference was found. Parameter
@@ -175,7 +200,11 @@ module RubyIndexer
         name: String,
         nesting: T::Array[String],
         seen_names: T::Array[String],
-      ).returns(T.nilable(T::Array[Entry]))
+      ).returns(T.nilable(T::Array[T.any(
+        Entry::Namespace,
+        Entry::Alias,
+        Entry::UnresolvedAlias,
+      )]))
     end
     def resolve(name, nesting, seen_names = [])
       # If we have a top level reference, then we just search for it straight away ignoring the nesting
@@ -204,7 +233,7 @@ module RubyIndexer
       return entries if entries
 
       # Finally, as a fallback, Ruby will search for the constant in the top level namespace
-      search_top_level(name, seen_names)
+      direct_or_aliased_constant(name, seen_names)
     rescue UnresolvableAliasError
       nil
     end
@@ -345,8 +374,25 @@ module RubyIndexer
       cached_ancestors = @ancestors[fully_qualified_name]
       return cached_ancestors if cached_ancestors
 
+      parts = fully_qualified_name.split("::")
+      singleton_levels = 0
+
+      parts.reverse_each do |part|
+        break unless part.include?("<Class:")
+
+        singleton_levels += 1
+        parts.pop
+      end
+
+      attached_class_name = parts.join("::")
+
       # If we don't have an entry for `name`, raise
       entries = self[fully_qualified_name]
+
+      if singleton_levels > 0 && !entries
+        entries = [existing_or_new_singleton_class(attached_class_name)]
+      end
+
       raise NonExistingNamespaceError, "No entry found for #{fully_qualified_name}" unless entries
 
       ancestors = [fully_qualified_name]
@@ -369,62 +415,25 @@ module RubyIndexer
       raise NonExistingNamespaceError,
         "None of the entries for #{fully_qualified_name} are modules or classes" if namespaces.empty?
 
-      mixin_operations = namespaces.flat_map(&:mixin_operations)
-      main_namespace_index = 0
-
       # The original nesting where we discovered this namespace, so that we resolve the correct names of the
       # included/prepended/extended modules and parent classes
       nesting = T.must(namespaces.first).nesting
 
-      mixin_operations.each do |operation|
-        resolved_module = resolve(operation.module_name, nesting)
-        next unless resolved_module
-
-        module_fully_qualified_name = T.must(resolved_module.first).name
-
-        case operation
-        when Entry::Prepend
-          # When a module is prepended, Ruby checks if it hasn't been prepended already to prevent adding it in front of
-          # the actual namespace twice. However, it does not check if it has been included because you are allowed to
-          # prepend the same module after it has already been included
-          linearized_prepends = linearized_ancestors_of(module_fully_qualified_name)
-
-          # When there are duplicate prepended modules, we have to insert the new prepends after the existing ones. For
-          # example, if the current ancestors are `["A", "Foo"]` and we try to prepend `["A", "B"]`, then `"B"` has to
-          # be inserted after `"A`
-          uniq_prepends = linearized_prepends - T.must(ancestors[0...main_namespace_index])
-          insert_position = linearized_prepends.length - uniq_prepends.length
-
-          T.unsafe(ancestors).insert(
-            insert_position,
-            *(linearized_prepends - T.must(ancestors[0...main_namespace_index])),
-          )
-
-          main_namespace_index += linearized_prepends.length
-        when Entry::Include
-          # When including a module, Ruby will always prevent duplicate entries in case the module has already been
-          # prepended or included
-          linearized_includes = linearized_ancestors_of(module_fully_qualified_name)
-          T.unsafe(ancestors).insert(main_namespace_index + 1, *(linearized_includes - ancestors))
+      if nesting.any?
+        singleton_levels.times do
+          nesting << "<Class:#{T.must(nesting.last)}>"
         end
       end
 
-      # Find the first class entry that has a parent class. Notice that if the developer makes a mistake and inherits
-      # from two diffent classes in different files, we simply ignore it
-      superclass = T.cast(namespaces.find { |n| n.is_a?(Entry::Class) && n.parent_class }, T.nilable(Entry::Class))
-
-      if superclass
-        # If the user makes a mistake and creates a class that inherits from itself, this method would throw a stack
-        # error. We need to ensure that this isn't the case
-        parent_class = T.must(superclass.parent_class)
-
-        resolved_parent_class = resolve(parent_class, nesting)
-        parent_class_name = resolved_parent_class&.first&.name
-
-        if parent_class_name && fully_qualified_name != parent_class_name
-          ancestors.concat(linearized_ancestors_of(parent_class_name))
-        end
-      end
+      linearize_mixins(ancestors, namespaces, nesting)
+      linearize_superclass(
+        ancestors,
+        attached_class_name,
+        fully_qualified_name,
+        namespaces,
+        nesting,
+        singleton_levels,
+      )
 
       ancestors
     end
@@ -484,8 +493,175 @@ module RubyIndexer
       @ancestors.clear if original_map.any? { |name, hash| updated_map[name] != hash }
     end
 
+    sig { returns(T::Boolean) }
+    def empty?
+      @entries.empty?
+    end
+
+    sig { returns(T::Array[String]) }
+    def names
+      @entries.keys
+    end
+
+    sig { params(name: String).returns(T::Boolean) }
+    def indexed?(name)
+      @entries.key?(name)
+    end
+
+    sig { returns(Integer) }
+    def length
+      @entries.count
+    end
+
+    sig { params(name: String).returns(Entry::SingletonClass) }
+    def existing_or_new_singleton_class(name)
+      *_namespace, unqualified_name = name.split("::")
+      full_singleton_name = "#{name}::<Class:#{unqualified_name}>"
+      singleton = T.cast(self[full_singleton_name]&.first, T.nilable(Entry::SingletonClass))
+
+      unless singleton
+        attached_ancestor = T.must(self[name]&.first)
+
+        singleton = Entry::SingletonClass.new(
+          [full_singleton_name],
+          attached_ancestor.file_path,
+          attached_ancestor.location,
+          attached_ancestor.name_location,
+          [],
+          nil,
+        )
+        add(singleton, skip_prefix_tree: true)
+      end
+
+      singleton
+    end
+
     private
 
+    # Linearize mixins for an array of namespace entries. This method will mutate the `ancestors` array with the
+    # linearized ancestors of the mixins
+    sig do
+      params(
+        ancestors: T::Array[String],
+        namespace_entries: T::Array[Entry::Namespace],
+        nesting: T::Array[String],
+      ).void
+    end
+    def linearize_mixins(ancestors, namespace_entries, nesting)
+      mixin_operations = namespace_entries.flat_map(&:mixin_operations)
+      main_namespace_index = 0
+
+      mixin_operations.each do |operation|
+        resolved_module = resolve(operation.module_name, nesting)
+        next unless resolved_module
+
+        module_fully_qualified_name = T.must(resolved_module.first).name
+
+        case operation
+        when Entry::Prepend
+          # When a module is prepended, Ruby checks if it hasn't been prepended already to prevent adding it in front of
+          # the actual namespace twice. However, it does not check if it has been included because you are allowed to
+          # prepend the same module after it has already been included
+          linearized_prepends = linearized_ancestors_of(module_fully_qualified_name)
+
+          # When there are duplicate prepended modules, we have to insert the new prepends after the existing ones. For
+          # example, if the current ancestors are `["A", "Foo"]` and we try to prepend `["A", "B"]`, then `"B"` has to
+          # be inserted after `"A`
+          uniq_prepends = linearized_prepends - T.must(ancestors[0...main_namespace_index])
+          insert_position = linearized_prepends.length - uniq_prepends.length
+
+          T.unsafe(ancestors).insert(
+            insert_position,
+            *(linearized_prepends - T.must(ancestors[0...main_namespace_index])),
+          )
+
+          main_namespace_index += linearized_prepends.length
+        when Entry::Include
+          # When including a module, Ruby will always prevent duplicate entries in case the module has already been
+          # prepended or included
+          linearized_includes = linearized_ancestors_of(module_fully_qualified_name)
+          T.unsafe(ancestors).insert(main_namespace_index + 1, *(linearized_includes - ancestors))
+        end
+      end
+    end
+
+    # Linearize the superclass of a given namespace (including modules with the implicit `Module` superclass). This
+    # method will mutate the `ancestors` array with the linearized ancestors of the superclass
+    sig do
+      params(
+        ancestors: T::Array[String],
+        attached_class_name: String,
+        fully_qualified_name: String,
+        namespace_entries: T::Array[Entry::Namespace],
+        nesting: T::Array[String],
+        singleton_levels: Integer,
+      ).void
+    end
+    def linearize_superclass( # rubocop:disable Metrics/ParameterLists
+      ancestors,
+      attached_class_name,
+      fully_qualified_name,
+      namespace_entries,
+      nesting,
+      singleton_levels
+    )
+      # Find the first class entry that has a parent class. Notice that if the developer makes a mistake and inherits
+      # from two diffent classes in different files, we simply ignore it
+      superclass = T.cast(
+        if singleton_levels > 0
+          self[attached_class_name]&.find { |n| n.is_a?(Entry::Class) && n.parent_class }
+        else
+          namespace_entries.find { |n| n.is_a?(Entry::Class) && n.parent_class }
+        end,
+        T.nilable(Entry::Class),
+      )
+
+      if superclass
+        # If the user makes a mistake and creates a class that inherits from itself, this method would throw a stack
+        # error. We need to ensure that this isn't the case
+        parent_class = T.must(superclass.parent_class)
+
+        resolved_parent_class = resolve(parent_class, nesting)
+        parent_class_name = resolved_parent_class&.first&.name
+
+        if parent_class_name && fully_qualified_name != parent_class_name
+
+          parent_name_parts = [parent_class_name]
+          singleton_levels.times do
+            parent_name_parts << "<Class:#{parent_name_parts.last}>"
+          end
+
+          ancestors.concat(linearized_ancestors_of(parent_name_parts.join("::")))
+        end
+
+        # When computing the linearization for a class's singleton class, it inherits from the linearized ancestors of
+        # the `Class` class
+        if parent_class_name&.start_with?("BasicObject") && singleton_levels > 0
+          class_class_name_parts = ["Class"]
+
+          (singleton_levels - 1).times do
+            class_class_name_parts << "<Class:#{class_class_name_parts.last}>"
+          end
+
+          ancestors.concat(linearized_ancestors_of(class_class_name_parts.join("::")))
+        end
+      elsif singleton_levels > 0
+        # When computing the linearization for a module's singleton class, it inherits from the linearized ancestors of
+        # the `Module` class
+        mod = T.cast(self[attached_class_name]&.find { |n| n.is_a?(Entry::Module) }, T.nilable(Entry::Module))
+
+        if mod
+          module_class_name_parts = ["Module"]
+
+          (singleton_levels - 1).times do
+            module_class_name_parts << "<Class:#{module_class_name_parts.last}>"
+          end
+
+          ancestors.concat(linearized_ancestors_of(module_class_name_parts.join("::")))
+        end
+      end
+    end
+
     # Attempts to resolve an UnresolvedAlias into a resolved Alias. If the unresolved alias is pointing to a constant
     # that doesn't exist, then we return the same UnresolvedAlias
     sig do
@@ -521,7 +697,11 @@ module RubyIndexer
         name: String,
         nesting: T::Array[String],
         seen_names: T::Array[String],
-      ).returns(T.nilable(T::Array[Entry]))
+      ).returns(T.nilable(T::Array[T.any(
+        Entry::Namespace,
+        Entry::Alias,
+        Entry::UnresolvedAlias,
+      )]))
     end
     def lookup_enclosing_scopes(name, nesting, seen_names)
       nesting.length.downto(1).each do |i|
@@ -546,7 +726,11 @@ module RubyIndexer
         name: String,
         nesting: T::Array[String],
         seen_names: T::Array[String],
-      ).returns(T.nilable(T::Array[Entry]))
+      ).returns(T.nilable(T::Array[T.any(
+        Entry::Namespace,
+        Entry::Alias,
+        Entry::UnresolvedAlias,
+      )]))
     end
     def lookup_ancestor_chain(name, nesting, seen_names)
       *nesting_parts, constant_name = build_non_redundant_full_name(name, nesting).split("::")
@@ -598,15 +782,29 @@ module RubyIndexer
       end
     end
 
-    sig { params(full_name: String, seen_names: T::Array[String]).returns(T.nilable(T::Array[Entry])) }
+    sig do
+      params(
+        full_name: String,
+        seen_names: T::Array[String],
+      ).returns(
+        T.nilable(T::Array[T.any(
+          Entry::Namespace,
+          Entry::Alias,
+          Entry::UnresolvedAlias,
+        )]),
+      )
+    end
     def direct_or_aliased_constant(full_name, seen_names)
       entries = @entries[full_name] || @entries[follow_aliased_namespace(full_name)]
-      entries&.map { |e| e.is_a?(Entry::UnresolvedAlias) ? resolve_alias(e, seen_names) : e }
-    end
 
-    sig { params(name: String, seen_names: T::Array[String]).returns(T.nilable(T::Array[Entry])) }
-    def search_top_level(name, seen_names)
-      @entries[name]&.map { |e| e.is_a?(Entry::UnresolvedAlias) ? resolve_alias(e, seen_names) : e }
+      T.cast(
+        entries&.map { |e| e.is_a?(Entry::UnresolvedAlias) ? resolve_alias(e, seen_names) : e },
+        T.nilable(T::Array[T.any(
+          Entry::Namespace,
+          Entry::Alias,
+          Entry::UnresolvedAlias,
+        )]),
+      )
     end
 
     # Attempt to resolve a given unresolved method alias. This method returns the resolved alias if we managed to

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

@@ -48,7 +48,7 @@ module RubyIndexer
       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)
+      class_entry = Entry::Class.new(nesting, file_path, location, location, comments, parent_class)
       add_declaration_mixins_to_entry(declaration, class_entry)
       @index.add(class_entry)
       declaration.members.each do |member|
@@ -64,7 +64,7 @@ module RubyIndexer
       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)
+      module_entry = Entry::Module.new(nesting, file_path, location, location, comments)
       add_declaration_mixins_to_entry(declaration, module_entry)
       @index.add(module_entry)
       declaration.members.each do |member|
@@ -93,16 +93,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
 
@@ -122,26 +121,8 @@ 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))
-    end
-
-    sig { params(owner: Entry::Namespace).returns(T.nilable(Entry::Class)) }
-    def existing_or_new_singleton_klass(owner)
-      *_parts, name = owner.name.split("::")
-
-      # Return the existing singleton class if available
-      singleton_entries = T.cast(
-        @index["#{owner.name}::<Class:#{name}>"],
-        T.nilable(T::Array[Entry::SingletonClass]),
-      )
-      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
+      real_owner = member.singleton? ? @index.existing_or_new_singleton_class(owner.name) : owner
+      @index.add(Entry::Method.new(name, file_path, location, location, comments, [], visibility, real_owner))
     end
   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,35 @@ 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
   end
 end