ruby-lsp 0.17.8 → 0.17.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e3a8a120b4cf3045cdeec98d2fb417ffdd300947b6426788d827346c43812ffc
-  data.tar.gz: b43a823e71fca99a9cf79b3a6ce19e7a0ec86e499b943aecae1666788859d055
+  metadata.gz: 7fafb2e9f1ef8ae394523d09256bce9016307821ab32ecd17fe645dd3f9d88f1
+  data.tar.gz: 74396754fdbf6dffb91ff4d6d237f67c26b92fd7ec0f187fc3e40627dc214de1
 SHA512:
-  metadata.gz: 9662d88d3f37b4fd7b744a69f38f2a20cd4bf00291f63968578e50bef3400916870efdcf58b6e81dd78a6829c4f8a7dd174e6d212ddc3a265420b29eaa2b6d8a
-  data.tar.gz: b788ef9185e02a732cd2dccef6273d8dd3fb471ebb8c2300b3ac78cc48d3952eee378a777cc4cf4ceb927590fff7bcdfc57c95f0924b21e589eb850ec9128641
+  metadata.gz: 8901ced915cabc4e749cc9451de7d7f9927c4025c6484002a682e65b1a20f7e52d38d3e5b52255b061998e8c114da8efeaaf605f0419fff8ed93c09cf00a2dae
+  data.tar.gz: 5679783fa6a828a7e6a3db9fb193ec9b4c1c094c6a67c187f7c2169f5f11fe53fe5024b0c7b0f08273eb46293639ff1d67f7787a851f4f1ac599be23a10ff7dd

data/README.md

@@ -33,7 +33,7 @@ The Ruby LSP features include
 - Completion for classes, modules, constants and require paths
 - Fuzzy search classes, modules and constants anywhere in the project and its dependencies (workspace symbol)
 
-Adding method support for definition, completion, hover and workspace symbol is partially supported, but not yet complete. Follow progress in https://github.com/Shopify/ruby-lsp/issues/899
+As of July 2024, Ruby LSP has received significant enhancements to its code navigation features. For an in-depth look at these improvements, including video demonstrations, check out this [article](https://railsatscale.com/2024-07-18-mastering-ruby-code-navigation-major-enhancements-in-ruby-lsp-2024/). Despite these advancements, we plan to continue enhancing its code navigation support even further. You can follow our progress on this [GitHub issue](https://github.com/Shopify/ruby-lsp/issues/899).
 
 See complete information about features [here](https://shopify.github.io/ruby-lsp/RubyLsp/Requests.html).
 

data/VERSION

@@ -1 +1 @@
-0.17.8
+0.17.10

data/exe/ruby-lsp

@@ -106,7 +106,7 @@ if options[:time_index]
 
   puts <<~MSG
     Ruby LSP v#{RubyLsp::VERSION}: Indexing took #{result.round(5)} seconds and generated:
-    - #{entries_by_entry_type.map { |k, v| "#{k.name.split("::").last}: #{v.size}" }.join("\n- ")}
+    - #{entries_by_entry_type.sort_by { |k, _| k.to_s }.map { |k, v| "#{k.name.split("::").last}: #{v.size}" }.join("\n- ")}
   MSG
   return
 end

data/lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb

@@ -504,17 +504,17 @@ module RubyIndexer
       @index.add(
         case value
         when Prism::ConstantReadNode, Prism::ConstantPathNode
-          Entry::UnresolvedAlias.new(value.slice, @stack.dup, name, @file_path, node.location, comments)
+          Entry::UnresolvedConstantAlias.new(value.slice, @stack.dup, name, @file_path, node.location, comments)
         when Prism::ConstantWriteNode, Prism::ConstantAndWriteNode, Prism::ConstantOrWriteNode,
         Prism::ConstantOperatorWriteNode
 
           # If the right hand side is another constant assignment, we need to visit it because that constant has to be
           # indexed too
-          Entry::UnresolvedAlias.new(value.name.to_s, @stack.dup, name, @file_path, node.location, comments)
+          Entry::UnresolvedConstantAlias.new(value.name.to_s, @stack.dup, name, @file_path, node.location, comments)
         when Prism::ConstantPathWriteNode, Prism::ConstantPathOrWriteNode, Prism::ConstantPathOperatorWriteNode,
         Prism::ConstantPathAndWriteNode
 
-          Entry::UnresolvedAlias.new(value.target.slice, @stack.dup, name, @file_path, node.location, comments)
+          Entry::UnresolvedConstantAlias.new(value.target.slice, @stack.dup, name, @file_path, node.location, comments)
         else
           Entry::Constant.new(name, @file_path, node.location, comments)
         end,

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

@@ -411,7 +411,7 @@ module RubyIndexer
     # All aliases are inserted as UnresolvedAlias in the index first and then we lazily resolve them to the correct
     # target in [rdoc-ref:Index#resolve]. If the right hand side contains a constant that doesn't exist, then it's not
     # possible to resolve the alias and it will remain an UnresolvedAlias until the right hand side constant exists
-    class UnresolvedAlias < Entry
+    class UnresolvedConstantAlias < Entry
       extend T::Sig
 
       sig { returns(String) }
@@ -439,13 +439,13 @@ module RubyIndexer
     end
 
     # Alias represents a resolved alias, which points to an existing constant target
-    class Alias < Entry
+    class ConstantAlias < Entry
       extend T::Sig
 
       sig { returns(String) }
       attr_reader :target
 
-      sig { params(target: String, unresolved_alias: UnresolvedAlias).void }
+      sig { params(target: String, unresolved_alias: UnresolvedConstantAlias).void }
       def initialize(target, unresolved_alias)
         super(unresolved_alias.name, unresolved_alias.file_path, unresolved_alias.location, unresolved_alias.comments)
 
@@ -492,7 +492,7 @@ module RubyIndexer
           old_name: String,
           owner: T.nilable(Entry::Namespace),
           file_path: String,
-          location: Prism::Location,
+          location: T.any(Prism::Location, RubyIndexer::Location),
           comments: T::Array[String],
         ).void
       end

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

@@ -84,6 +84,34 @@ module RubyIndexer
       @require_paths_tree.search(query)
     end
 
+    # Searches for a constant based on an unqualified name and returns the first possible match regardless of whether
+    # there are more possible matching entries
+    sig do
+      params(
+        name: String,
+      ).returns(T.nilable(T::Array[T.any(
+        Entry::Namespace,
+        Entry::ConstantAlias,
+        Entry::UnresolvedConstantAlias,
+        Entry::Constant,
+      )]))
+    end
+    def first_unqualified_const(name)
+      _name, entries = @entries.find do |const_name, _entries|
+        const_name.end_with?(name)
+      end
+
+      T.cast(
+        entries,
+        T.nilable(T::Array[T.any(
+          Entry::Namespace,
+          Entry::ConstantAlias,
+          Entry::UnresolvedConstantAlias,
+          Entry::Constant,
+        )]),
+      )
+    end
+
     # Searches entries in the index based on an exact prefix, intended for providing autocomplete. All possible matches
     # to the prefix are returned. The return is an array of arrays, where each entry is the array of entries for a given
     # name match. For example:
@@ -202,8 +230,8 @@ module RubyIndexer
         seen_names: T::Array[String],
       ).returns(T.nilable(T::Array[T.any(
         Entry::Namespace,
-        Entry::Alias,
-        Entry::UnresolvedAlias,
+        Entry::ConstantAlias,
+        Entry::UnresolvedConstantAlias,
       )]))
     end
     def resolve(name, nesting, seen_names = [])
@@ -248,6 +276,7 @@ module RubyIndexer
       ).void
     end
     def index_all(indexable_paths: RubyIndexer.configuration.indexables, &block)
+      RBSIndexer.new(self).index_ruby_core
       # Calculate how many paths are worth 1% of progress
       progress_step = (indexable_paths.length / 100.0).ceil
 
@@ -305,13 +334,13 @@ module RubyIndexer
         entry = @entries[current_name]&.first
 
         case entry
-        when Entry::Alias
+        when Entry::ConstantAlias
           target = entry.target
           return follow_aliased_namespace("#{target}::#{real_parts.join("::")}", seen_names)
-        when Entry::UnresolvedAlias
+        when Entry::UnresolvedConstantAlias
           resolved = resolve_alias(entry, seen_names)
 
-          if resolved.is_a?(Entry::UnresolvedAlias)
+          if resolved.is_a?(Entry::UnresolvedConstantAlias)
             raise UnresolvableAliasError, "The constant #{resolved.name} is an alias to a non existing constant"
           end
 
@@ -410,7 +439,7 @@ module RubyIndexer
         case entry
         when Entry::Namespace
           entry
-        when Entry::Alias
+        when Entry::ConstantAlias
           self[entry.target]&.grep(Entry::Namespace)
         end
       end.flatten
@@ -420,7 +449,7 @@ module RubyIndexer
 
       # 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
+      nesting = T.must(namespaces.first).nesting.flat_map { |n| n.split("::") }
 
       if nesting.any?
         singleton_levels.times do
@@ -629,7 +658,7 @@ module RubyIndexer
 
         if parent_class_name && fully_qualified_name != parent_class_name
 
-          parent_name_parts = [parent_class_name]
+          parent_name_parts = parent_class_name.split("::")
           singleton_levels.times do
             parent_name_parts << "<Class:#{parent_name_parts.last}>"
           end
@@ -669,9 +698,9 @@ module RubyIndexer
     # that doesn't exist, then we return the same UnresolvedAlias
     sig do
       params(
-        entry: Entry::UnresolvedAlias,
+        entry: Entry::UnresolvedConstantAlias,
         seen_names: T::Array[String],
-      ).returns(T.any(Entry::Alias, Entry::UnresolvedAlias))
+      ).returns(T.any(Entry::ConstantAlias, Entry::UnresolvedConstantAlias))
     end
     def resolve_alias(entry, seen_names)
       alias_name = entry.name
@@ -683,7 +712,7 @@ module RubyIndexer
       return entry unless target
 
       target_name = T.must(target.first).name
-      resolved_alias = Entry::Alias.new(target_name, entry)
+      resolved_alias = Entry::ConstantAlias.new(target_name, entry)
 
       # Replace the UnresolvedAlias by a resolved one so that we don't have to do this again later
       original_entries = T.must(@entries[alias_name])
@@ -702,8 +731,8 @@ module RubyIndexer
         seen_names: T::Array[String],
       ).returns(T.nilable(T::Array[T.any(
         Entry::Namespace,
-        Entry::Alias,
-        Entry::UnresolvedAlias,
+        Entry::ConstantAlias,
+        Entry::UnresolvedConstantAlias,
       )]))
     end
     def lookup_enclosing_scopes(name, nesting, seen_names)
@@ -731,8 +760,8 @@ module RubyIndexer
         seen_names: T::Array[String],
       ).returns(T.nilable(T::Array[T.any(
         Entry::Namespace,
-        Entry::Alias,
-        Entry::UnresolvedAlias,
+        Entry::ConstantAlias,
+        Entry::UnresolvedConstantAlias,
       )]))
     end
     def lookup_ancestor_chain(name, nesting, seen_names)
@@ -792,8 +821,8 @@ module RubyIndexer
       ).returns(
         T.nilable(T::Array[T.any(
           Entry::Namespace,
-          Entry::Alias,
-          Entry::UnresolvedAlias,
+          Entry::ConstantAlias,
+          Entry::UnresolvedConstantAlias,
         )]),
       )
     end
@@ -801,11 +830,11 @@ module RubyIndexer
       entries = @entries[full_name] || @entries[follow_aliased_namespace(full_name)]
 
       T.cast(
-        entries&.map { |e| e.is_a?(Entry::UnresolvedAlias) ? resolve_alias(e, seen_names) : e },
+        entries&.map { |e| e.is_a?(Entry::UnresolvedConstantAlias) ? resolve_alias(e, seen_names) : e },
         T.nilable(T::Array[T.any(
           Entry::Namespace,
-          Entry::Alias,
-          Entry::UnresolvedAlias,
+          Entry::ConstantAlias,
+          Entry::UnresolvedConstantAlias,
         )]),
       )
     end

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

@@ -37,45 +37,43 @@ module RubyIndexer
     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, 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, 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
 
@@ -115,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
@@ -224,5 +222,60 @@ module RubyIndexer
 
       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,
+      )
+
+      @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/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

data/lib/ruby_indexer/test/index_test.rb

@@ -181,20 +181,20 @@ module RubyIndexer
 
     def test_resolving_aliases_to_non_existing_constants_with_conflicting_names
       @index.index_single(IndexablePath.new("/fake", "/fake/path/foo.rb"), <<~RUBY)
-        class Float
+        class Bar
         end
 
         module Foo
-          class Float < self
-            INFINITY = ::Float::INFINITY
+          class Bar < self
+            BAZ = ::Bar::BAZ
           end
         end
       RUBY
 
-      entry = @index.resolve("INFINITY", ["Foo", "Float"]).first
+      entry = @index.resolve("BAZ", ["Foo", "Bar"]).first
       refute_nil(entry)
 
-      assert_instance_of(Entry::UnresolvedAlias, entry)
+      assert_instance_of(Entry::UnresolvedConstantAlias, entry)
     end
 
     def test_visitor_does_not_visit_unnecessary_nodes
@@ -1015,11 +1015,11 @@ module RubyIndexer
 
       foo_entry = T.must(@index.resolve("FOO", ["Namespace"])&.first)
       assert_equal(2, foo_entry.location.start_line)
-      assert_instance_of(Entry::Alias, foo_entry)
+      assert_instance_of(Entry::ConstantAlias, foo_entry)
 
       bar_entry = T.must(@index.resolve("BAR", ["Namespace"])&.first)
       assert_equal(3, bar_entry.location.start_line)
-      assert_instance_of(Entry::Alias, bar_entry)
+      assert_instance_of(Entry::ConstantAlias, bar_entry)
     end
 
     def test_resolving_circular_alias_three_levels
@@ -1033,15 +1033,15 @@ module RubyIndexer
 
       foo_entry = T.must(@index.resolve("FOO", ["Namespace"])&.first)
       assert_equal(2, foo_entry.location.start_line)
-      assert_instance_of(Entry::Alias, foo_entry)
+      assert_instance_of(Entry::ConstantAlias, foo_entry)
 
       bar_entry = T.must(@index.resolve("BAR", ["Namespace"])&.first)
       assert_equal(3, bar_entry.location.start_line)
-      assert_instance_of(Entry::Alias, bar_entry)
+      assert_instance_of(Entry::ConstantAlias, bar_entry)
 
       baz_entry = T.must(@index.resolve("BAZ", ["Namespace"])&.first)
       assert_equal(4, baz_entry.location.start_line)
-      assert_instance_of(Entry::Alias, baz_entry)
+      assert_instance_of(Entry::ConstantAlias, baz_entry)
     end
 
     def test_resolving_constants_in_aliased_namespace
@@ -1542,6 +1542,21 @@ module RubyIndexer
       assert_empty(@index.method_completion_candidates("bar", "Foo"))
     end
 
+    def test_first_unqualified_const
+      index(<<~RUBY)
+        module Foo
+          class Bar; end
+        end
+
+        module Baz
+          class Bar; end
+        end
+      RUBY
+
+      entry = T.must(@index.first_unqualified_const("Bar")&.first)
+      assert_equal("Foo::Bar", entry.name)
+    end
+
     def test_completion_does_not_duplicate_overridden_methods
       index(<<~RUBY)
         class Foo
@@ -1750,5 +1765,62 @@ module RubyIndexer
         @index.linearized_ancestors_of("A::<Class:A>")
       end
     end
+
+    def test_linearizing_singleton_parent_class_with_namespace
+      index(<<~RUBY)
+        class ActiveRecord::Base; end
+
+        class User < ActiveRecord::Base
+        end
+      RUBY
+
+      assert_equal(
+        [
+          "User::<Class:User>",
+          "ActiveRecord::Base::<Class:Base>",
+          "Object::<Class:Object>",
+          "BasicObject::<Class:BasicObject>",
+          "Class",
+          "Module",
+          "Object",
+          "Kernel",
+          "BasicObject",
+        ],
+        @index.linearized_ancestors_of("User::<Class:User>"),
+      )
+    end
+
+    def test_singleton_nesting_is_correctly_split_during_linearization
+      index(<<~RUBY)
+        module Bar; end
+
+        module Foo
+          class Namespace::Parent
+            extend Bar
+          end
+        end
+
+        module Foo
+          class Child < Namespace::Parent
+          end
+        end
+      RUBY
+
+      assert_equal(
+        [
+          "Foo::Child::<Class:Child>",
+          "Foo::Namespace::Parent::<Class:Parent>",
+          "Bar",
+          "Object::<Class:Object>",
+          "BasicObject::<Class:BasicObject>",
+          "Class",
+          "Module",
+          "Object",
+          "Kernel",
+          "BasicObject",
+        ],
+        @index.linearized_ancestors_of("Foo::Child::<Class:Child>"),
+      )
+    end
   end
 end