ruby-lsp 0.10.1 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 36eafde3135250941805bf340b782dfab3002839b66ba4722d261edd7fe1356a
-  data.tar.gz: f8dbfe5eb36489223c21d2e816f91324d0928895632a4344c16ecc756c0cb279
+  metadata.gz: 7491255b178e72942f0b98ae97c83020c0a5726162d556fba7a2592a2c8b5132
+  data.tar.gz: d9c61449b9d3eb43a53a8c00b704ceab8691bb404dedd3324d3ad055d859974d
 SHA512:
-  metadata.gz: 24312d8a758e8388c02165d8f0ee4a8f8ccb93bb71efbd3ed3a4eeeadeb750373856cdcd3842f2cb1138ef7067c7c497260adeee347cc37f81e960a1febb7a44
-  data.tar.gz: c637ef4a50da10f0a7d81a15e9fc7af209e6a056642c93b315e0410fbfe732a8f42cd841ca3d70f66fac79d54474253a8febfe60f487c970632e64fd88ce103b
+  metadata.gz: 88b6b4d22784336e299caa42e09a701bd9c70ac3176c224c00700ad80605dd8ad17d4274eedc95dad4f6c6432fb192c2094ca8b5ca66ce3ab95bf7ba3eb68831
+  data.tar.gz: caabe89725f634f87ace44cc85c4d001a8f74dbbb0f2d59f1e2e7a763a3b7896e72a6432abbba7e85e07646ebfc7c812c1126ef8afda520a9f827b58a8cc881d

data/README.md

@@ -46,14 +46,14 @@ See the [documentation](https://shopify.github.io/ruby-lsp) for more in-depth de
 For creating rich themes for Ruby using the semantic highlighting information, see the [semantic highlighting
 documentation](SEMANTIC_HIGHLIGHTING.md).
 
-### Extensions
+### Addons
 
-The Ruby LSP provides a server extension system that allows other gems to enhance the base functionality with more
-editor features. This is the mechanism that powers extensions like
+The Ruby LSP provides an addon system that allows other gems to enhance the base functionality with more editor
+features. This is the mechanism that powers addons like
 
 - [Ruby LSP Rails](https://github.com/Shopify/ruby-lsp-rails)
 
-For instructions on how to create extensions, see the [server extensions documentation](SERVER_EXTENSIONS.md).
+For instructions on how to create addons, see the [addons documentation](ADDONS.md).
 
 ## Learn More
 

data/VERSION

@@ -1 +1 @@
-0.10.1
+0.11.0

data/exe/ruby-lsp-check

@@ -16,7 +16,7 @@ end
 
 require_relative "../lib/ruby_lsp/internal"
 
-RubyLsp::Extension.load_extensions
+RubyLsp::Addon.load_addons
 
 T::Utils.run_all_sig_blocks
 

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

@@ -18,11 +18,7 @@ module RubyIndexer
 
     sig { void }
     def initialize
-      excluded_gem_names = Bundler.definition.dependencies.filter_map do |dependency|
-        dependency.name if dependency.groups == [:development]
-      end
-
-      @excluded_gems = T.let(excluded_gem_names, T::Array[String])
+      @excluded_gems = T.let(initial_excluded_gems, T::Array[String])
       @included_gems = T.let([], T::Array[String])
       @excluded_patterns = T.let([File.join("**", "*_test.rb")], T::Array[String])
       path = Bundler.settings["path"]
@@ -174,5 +170,39 @@ module RubyIndexer
       @included_patterns.concat(config["included_patterns"]) if config["included_patterns"]
       @excluded_magic_comments.concat(config["excluded_magic_comments"]) if config["excluded_magic_comments"]
     end
+
+    sig { returns(T::Array[String]) }
+    def initial_excluded_gems
+      excluded, others = Bundler.definition.dependencies.partition do |dependency|
+        dependency.groups == [:development]
+      end
+
+      # When working on a gem, we need to make sure that its gemspec dependencies can't be excluded. This is necessary
+      # because Bundler doesn't assign groups to gemspec dependencies
+      this_gem = Bundler.definition.dependencies.find { |d| d.to_spec.full_gem_path == Dir.pwd }
+      others.concat(this_gem.to_spec.dependencies) if this_gem
+
+      excluded.each do |dependency|
+        next unless dependency.runtime?
+
+        dependency.to_spec.dependencies.each do |transitive_dependency|
+          # If the transitive dependency is included in other groups, skip it
+          next if others.any? { |d| d.name == transitive_dependency.name }
+
+          # If the transitive dependency is included as a transitive dependency of a gem outside of the development
+          # group, skip it
+          next if others.any? { |d| d.to_spec.dependencies.include?(transitive_dependency) }
+
+          excluded << transitive_dependency
+        end
+      rescue Gem::MissingSpecError
+        # If a gem is scoped only to some specific platform, then its dependencies may not be installed either, but they
+        # are still listed in dependencies. We can't index them because they are not installed for the platform, so we
+        # just ignore if they're missing
+      end
+
+      excluded.uniq!
+      excluded.map(&:name)
+    end
   end
 end

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

@@ -5,6 +5,8 @@ module RubyIndexer
   class Index
     extend T::Sig
 
+    class UnresolvableAliasError < StandardError; end
+
     # The minimum Jaro-Winkler similarity score for an entry to be considered a match for a given fuzzy search query
     ENTRY_SIMILARITY_THRESHOLD = 0.7
 
@@ -125,13 +127,29 @@ module RubyIndexer
     # 3. Baz
     sig { params(name: String, nesting: T::Array[String]).returns(T.nilable(T::Array[Entry])) }
     def resolve(name, nesting)
-      (nesting.length + 1).downto(0).each do |i|
-        prefix = T.must(nesting[0...i]).join("::")
-        full_name = prefix.empty? ? name : "#{prefix}::#{name}"
-        entries = @entries[full_name]
-        return entries if entries
+      if name.start_with?("::")
+        name = name.delete_prefix("::")
+        results = @entries[name] || @entries[follow_aliased_namespace(name)]
+        return results.map { |e| e.is_a?(Entry::UnresolvedAlias) ? resolve_alias(e) : e } if results
       end
 
+      nesting.length.downto(0).each do |i|
+        namespace = T.must(nesting[0...i]).join("::")
+        full_name = namespace.empty? ? name : "#{namespace}::#{name}"
+
+        # If we find an entry with `full_name` directly, then we can already return it, even if it contains aliases -
+        # because the user might be trying to jump to the alias definition.
+        #
+        # However, if we don't find it, then we need to search for possible aliases in the namespace. For example, in
+        # the LSP itself we alias `RubyLsp::Interface` to `LanguageServer::Protocol::Interface`, which means doing
+        # `RubyLsp::Interface::Location` is allowed. For these cases, we need some way to realize that the
+        # `RubyLsp::Interface` part is an alias, that has to be resolved
+        entries = @entries[full_name] || @entries[follow_aliased_namespace(full_name)]
+        return entries.map { |e| e.is_a?(Entry::UnresolvedAlias) ? resolve_alias(e) : e } if entries
+      end
+
+      nil
+    rescue UnresolvableAliasError
       nil
     end
 
@@ -152,6 +170,68 @@ module RubyIndexer
       # If `path` is a directory, just ignore it and continue indexing
     end
 
+    # Follows aliases in a namespace. The algorithm keeps checking if the name is an alias and then recursively follows
+    # it. The idea is that we test the name in parts starting from the complete name to the first namespace. For
+    # `Foo::Bar::Baz`, we would test:
+    # 1. Is `Foo::Bar::Baz` an alias? Get the target and recursively follow its target
+    # 2. Is `Foo::Bar` an alias? Get the target and recursively follow its target
+    # 3. Is `Foo` an alias? Get the target and recursively follow its target
+    #
+    # If we find an alias, then we want to follow its target. In the same example, if `Foo::Bar` is an alias to
+    # `Something::Else`, then we first discover `Something::Else::Baz`. But `Something::Else::Baz` might contain other
+    # aliases, so we have to invoke `follow_aliased_namespace` again to check until we only return a real name
+    sig { params(name: String).returns(String) }
+    def follow_aliased_namespace(name)
+      parts = name.split("::")
+      real_parts = []
+
+      (parts.length - 1).downto(0).each do |i|
+        current_name = T.must(parts[0..i]).join("::")
+        entry = @entries[current_name]&.first
+
+        case entry
+        when Entry::Alias
+          target = entry.target
+          return follow_aliased_namespace("#{target}::#{real_parts.join("::")}")
+        when Entry::UnresolvedAlias
+          resolved = resolve_alias(entry)
+
+          if resolved.is_a?(Entry::UnresolvedAlias)
+            raise UnresolvableAliasError, "The constant #{resolved.name} is an alias to a non existing constant"
+          end
+
+          target = resolved.target
+          return follow_aliased_namespace("#{target}::#{real_parts.join("::")}")
+        else
+          real_parts.unshift(T.must(parts[i]))
+        end
+      end
+
+      real_parts.join("::")
+    end
+
+    private
+
+    # 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 { params(entry: Entry::UnresolvedAlias).returns(T.any(Entry::Alias, Entry::UnresolvedAlias)) }
+    def resolve_alias(entry)
+      target = resolve(entry.target, entry.nesting)
+      return entry unless target
+
+      target_name = T.must(target.first).name
+      resolved_alias = Entry::Alias.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[entry.name])
+      original_entries.delete(entry)
+      original_entries << resolved_alias
+
+      @entries_tree.insert(entry.name, original_entries)
+
+      resolved_alias
+    end
+
     class Entry
       extend T::Sig
 
@@ -167,12 +247,16 @@ module RubyIndexer
       sig { returns(T::Array[String]) }
       attr_reader :comments
 
+      sig { returns(Symbol) }
+      attr_accessor :visibility
+
       sig { params(name: String, file_path: String, location: YARP::Location, comments: T::Array[String]).void }
       def initialize(name, file_path, location, comments)
         @name = name
         @file_path = file_path
         @location = location
         @comments = comments
+        @visibility = T.let(:public, Symbol)
       end
 
       sig { returns(String) }
@@ -195,6 +279,58 @@ module RubyIndexer
 
       class Constant < Entry
       end
+
+      # An UnresolvedAlias points to a constant alias with a right hand side that has not yet been resolved. For
+      # example, if we find
+      #
+      # ```ruby
+      #   CONST = Foo
+      # ```
+      # Before we have discovered `Foo`, there's no way to eagerly resolve this alias to the correct target constant.
+      # 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
+        extend T::Sig
+
+        sig { returns(String) }
+        attr_reader :target
+
+        sig { returns(T::Array[String]) }
+        attr_reader :nesting
+
+        sig do
+          params(
+            target: String,
+            nesting: T::Array[String],
+            name: String,
+            file_path: String,
+            location: YARP::Location,
+            comments: T::Array[String],
+          ).void
+        end
+        def initialize(target, nesting, name, file_path, location, comments) # rubocop:disable Metrics/ParameterLists
+          super(name, file_path, location, comments)
+
+          @target = target
+          @nesting = nesting
+        end
+      end
+
+      # Alias represents a resolved alias, which points to an existing constant target
+      class Alias < Entry
+        extend T::Sig
+
+        sig { returns(String) }
+        attr_reader :target
+
+        sig { params(target: String, unresolved_alias: UnresolvedAlias).void }
+        def initialize(target, unresolved_alias)
+          super(unresolved_alias.name, unresolved_alias.file_path, unresolved_alias.location, unresolved_alias.comments)
+
+          @target = target
+        end
+      end
     end
   end
 end

data/lib/ruby_indexer/lib/ruby_indexer/visitor.rb

@@ -36,9 +36,19 @@ module RubyIndexer
       when YARP::ModuleNode
         add_index_entry(node, Index::Entry::Module)
       when YARP::ConstantWriteNode, YARP::ConstantOrWriteNode
-        add_constant(node)
-      when YARP::ConstantPathWriteNode, YARP::ConstantPathOrWriteNode
-        add_constant_with_path(node)
+        name = fully_qualify_name(node.name.to_s)
+        add_constant(node, name)
+      when YARP::ConstantPathWriteNode, YARP::ConstantPathOrWriteNode, YARP::ConstantPathOperatorWriteNode,
+        YARP::ConstantPathAndWriteNode
+
+        # ignore variable constants like `var::FOO` or `self.class::FOO`
+        return unless node.target.parent.nil? || node.target.parent.is_a?(YARP::ConstantReadNode)
+
+        name = fully_qualify_name(node.target.location.slice)
+        add_constant(node, name)
+      when YARP::CallNode
+        message = node.message
+        handle_private_constant(node) if message == "private_constant"
       end
     end
 
@@ -50,28 +60,66 @@ module RubyIndexer
 
     private
 
-    sig do
-      params(
-        node: T.any(YARP::ConstantWriteNode, YARP::ConstantOrWriteNode),
-      ).void
-    end
-    def add_constant(node)
-      comments = collect_comments(node)
-      @index << Index::Entry::Constant.new(fully_qualify_name(node.name.to_s), @file_path, node.location, comments)
+    sig { params(node: YARP::CallNode).void }
+    def handle_private_constant(node)
+      arguments = node.arguments&.arguments
+      return unless arguments
+
+      first_argument = arguments.first
+
+      name = case first_argument
+      when YARP::StringNode
+        first_argument.content
+      when YARP::SymbolNode
+        first_argument.value
+      end
+
+      return unless name
+
+      receiver = node.receiver
+      name = "#{receiver.slice}::#{name}" if receiver
+
+      # The private_constant method does not resolve the constant name. It always points to a constant that needs to
+      # exist in the current namespace
+      entries = @index[fully_qualify_name(name)]
+      entries&.each { |entry| entry.visibility = :private }
     end
 
     sig do
       params(
-        node: T.any(YARP::ConstantPathWriteNode, YARP::ConstantPathOrWriteNode),
+        node: T.any(
+          YARP::ConstantWriteNode,
+          YARP::ConstantOrWriteNode,
+          YARP::ConstantPathWriteNode,
+          YARP::ConstantPathOrWriteNode,
+          YARP::ConstantPathOperatorWriteNode,
+          YARP::ConstantPathAndWriteNode,
+        ),
+        name: String,
       ).void
     end
-    def add_constant_with_path(node)
-      # ignore variable constants like `var::FOO` or `self.class::FOO`
-      return unless node.target.parent.nil? || node.target.parent.is_a?(YARP::ConstantReadNode)
-
-      name = node.target.location.slice
+    def add_constant(node, name)
+      value = node.value
       comments = collect_comments(node)
-      @index << Index::Entry::Constant.new(fully_qualify_name(name), @file_path, node.location, comments)
+
+      @index << case value
+      when YARP::ConstantReadNode, YARP::ConstantPathNode
+        Index::Entry::UnresolvedAlias.new(value.slice, @stack.dup, name, @file_path, node.location, comments)
+      when YARP::ConstantWriteNode, YARP::ConstantAndWriteNode, YARP::ConstantOrWriteNode,
+        YARP::ConstantOperatorWriteNode
+
+        # If the right hand side is another constant assignment, we need to visit it because that constant has to be
+        # indexed too
+        visit(value)
+        Index::Entry::UnresolvedAlias.new(value.name.to_s, @stack.dup, name, @file_path, node.location, comments)
+      when YARP::ConstantPathWriteNode, YARP::ConstantPathOrWriteNode, YARP::ConstantPathOperatorWriteNode,
+        YARP::ConstantPathAndWriteNode
+
+        visit(value)
+        Index::Entry::UnresolvedAlias.new(value.target.slice, @stack.dup, name, @file_path, node.location, comments)
+      else
+        Index::Entry::Constant.new(name, @file_path, node.location, comments)
+      end
     end
 
     sig { params(node: T.any(YARP::ClassNode, YARP::ModuleNode), klass: T.class_of(Index::Entry)).void }

data/lib/ruby_indexer/test/classes_and_modules_test.rb

@@ -216,5 +216,28 @@ module RubyIndexer
       second_foo_entry = @index["Bar"][0]
       assert_equal("This is a Bar comment", second_foo_entry.comments.join("\n"))
     end
+
+    def test_private_class_and_module_indexing
+      index(<<~RUBY)
+        class A
+          class B; end
+          private_constant(:B)
+
+          module C; end
+          private_constant("C")
+
+          class D; end
+        end
+      RUBY
+
+      b_const = @index["A::B"].first
+      assert_equal(:private, b_const.visibility)
+
+      c_const = @index["A::C"].first
+      assert_equal(:private, c_const.visibility)
+
+      d_const = @index["A::D"].first
+      assert_equal(:public, d_const.visibility)
+    end
   end
 end

data/lib/ruby_indexer/test/configuration_test.rb

@@ -15,6 +15,8 @@ module RubyIndexer
 
       assert(indexables.none? { |indexable| indexable.full_path.include?("test/fixtures") })
       assert(indexables.none? { |indexable| indexable.full_path.include?("minitest-reporters") })
+      assert(indexables.none? { |indexable| indexable.full_path.include?("ansi") })
+      assert(indexables.any? { |indexable| indexable.full_path.include?("sorbet-runtime") })
       assert(indexables.none? { |indexable| indexable.full_path == __FILE__ })
     end
 

data/lib/ruby_indexer/test/constant_test.rb

@@ -104,5 +104,207 @@ module RubyIndexer
 
       assert_no_entry
     end
+
+    def test_private_constant_indexing
+      index(<<~RUBY)
+        class A
+          B = 1
+          private_constant(:B)
+
+          C = 2
+          private_constant("C")
+
+          D = 1
+        end
+      RUBY
+
+      b_const = @index["A::B"].first
+      assert_equal(:private, b_const.visibility)
+
+      c_const = @index["A::C"].first
+      assert_equal(:private, c_const.visibility)
+
+      d_const = @index["A::D"].first
+      assert_equal(:public, d_const.visibility)
+    end
+
+    def test_marking_constants_as_private_reopening_namespaces
+      index(<<~RUBY)
+        module A
+          module B
+            CONST_A = 1
+            private_constant(:CONST_A)
+
+            CONST_B = 2
+            CONST_C = 3
+          end
+
+          module B
+            private_constant(:CONST_B)
+          end
+        end
+
+        module A
+          module B
+            private_constant(:CONST_C)
+          end
+        end
+      RUBY
+
+      a_const = @index["A::B::CONST_A"].first
+      assert_equal(:private, a_const.visibility)
+
+      b_const = @index["A::B::CONST_B"].first
+      assert_equal(:private, b_const.visibility)
+
+      c_const = @index["A::B::CONST_C"].first
+      assert_equal(:private, c_const.visibility)
+    end
+
+    def test_marking_constants_as_private_with_receiver
+      index(<<~RUBY)
+        module A
+          module B
+            CONST_A = 1
+            CONST_B = 2
+          end
+
+          B.private_constant(:CONST_A)
+        end
+
+        A::B.private_constant(:CONST_B)
+      RUBY
+
+      a_const = @index["A::B::CONST_A"].first
+      assert_equal(:private, a_const.visibility)
+
+      b_const = @index["A::B::CONST_B"].first
+      assert_equal(:private, b_const.visibility)
+    end
+
+    def test_indexing_constant_aliases
+      index(<<~RUBY)
+        module A
+          module B
+            module C
+            end
+          end
+
+          FIRST = B::C
+        end
+
+        SECOND = A::FIRST
+      RUBY
+
+      unresolve_entry = @index["A::FIRST"].first
+      assert_instance_of(Index::Entry::UnresolvedAlias, 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(Index::Entry::Alias, resolved_entry)
+      assert_equal("A::B::C", resolved_entry.target)
+    end
+
+    def test_aliasing_namespaces
+      index(<<~RUBY)
+        module A
+          module B
+            module C
+            end
+          end
+
+          ALIAS = B
+        end
+
+        module Other
+          ONE_MORE = A::ALIAS
+        end
+      RUBY
+
+      unresolve_entry = @index["A::ALIAS"].first
+      assert_instance_of(Index::Entry::UnresolvedAlias, unresolve_entry)
+      assert_equal(["A"], unresolve_entry.nesting)
+      assert_equal("B", unresolve_entry.target)
+
+      resolved_entry = @index.resolve("ALIAS", ["A"]).first
+      assert_instance_of(Index::Entry::Alias, resolved_entry)
+      assert_equal("A::B", resolved_entry.target)
+
+      resolved_entry = @index.resolve("ALIAS::C", ["A"]).first
+      assert_instance_of(Index::Entry::Module, resolved_entry)
+      assert_equal("A::B::C", resolved_entry.name)
+
+      unresolve_entry = @index["Other::ONE_MORE"].first
+      assert_instance_of(Index::Entry::UnresolvedAlias, unresolve_entry)
+      assert_equal(["Other"], unresolve_entry.nesting)
+      assert_equal("A::ALIAS", unresolve_entry.target)
+
+      resolved_entry = @index.resolve("Other::ONE_MORE::C", []).first
+      assert_instance_of(Index::Entry::Module, resolved_entry)
+    end
+
+    def test_indexing_same_line_constant_aliases
+      index(<<~RUBY)
+        module A
+          B = C = 1
+          D = E ||= 1
+          F = G::H &&= 1
+          I::J = K::L = M = 1
+        end
+      RUBY
+
+      # B and C
+      unresolve_entry = @index["A::B"].first
+      assert_instance_of(Index::Entry::UnresolvedAlias, unresolve_entry)
+      assert_equal(["A"], unresolve_entry.nesting)
+      assert_equal("C", unresolve_entry.target)
+
+      resolved_entry = @index.resolve("A::B", []).first
+      assert_instance_of(Index::Entry::Alias, resolved_entry)
+      assert_equal("A::C", resolved_entry.target)
+
+      constant = @index["A::C"].first
+      assert_instance_of(Index::Entry::Constant, constant)
+
+      # D and E
+      unresolve_entry = @index["A::D"].first
+      assert_instance_of(Index::Entry::UnresolvedAlias, unresolve_entry)
+      assert_equal(["A"], unresolve_entry.nesting)
+      assert_equal("E", unresolve_entry.target)
+
+      resolved_entry = @index.resolve("A::D", []).first
+      assert_instance_of(Index::Entry::Alias, resolved_entry)
+      assert_equal("A::E", resolved_entry.target)
+
+      # F and G::H
+      unresolve_entry = @index["A::F"].first
+      assert_instance_of(Index::Entry::UnresolvedAlias, 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(Index::Entry::Alias, 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(Index::Entry::UnresolvedAlias, 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(Index::Entry::Alias, 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(Index::Entry::Alias, resolved_entry)
+      assert_equal("A::M", resolved_entry.target)
+
+      constant = @index["A::M"].first
+      assert_instance_of(Index::Entry::Constant, constant)
+    end
   end
 end

data/lib/ruby_indexer/test/index_test.rb

@@ -158,5 +158,25 @@ module RubyIndexer
       results = @index.prefix_search("Ba", ["Foo"]).map { |entries| entries.map(&:name) }
       assert_equal([["Foo::Bar", "Foo::Bar"], ["Foo::Baz"]], results)
     end
+
+    def test_resolve_normalizes_top_level_names
+      @index.index_single(IndexablePath.new("/fake", "/fake/path/foo.rb"), <<~RUBY)
+        class Bar; end
+
+        module Foo
+          class Bar; end
+        end
+      RUBY
+
+      entries = @index.resolve("::Foo::Bar", [])
+      refute_nil(entries)
+
+      assert_equal("Foo::Bar", entries.first.name)
+
+      entries = @index.resolve("::Bar", ["Foo"])
+      refute_nil(entries)
+
+      assert_equal("Bar", entries.first.name)
+    end
   end
 end