ruby-lsp 0.23.15 → 0.26.9

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

@@ -3,13 +3,8 @@
 
 module RubyIndexer
   class Entry
-    class Visibility < T::Enum
-      enums do
-        PUBLIC = new(:public)
-        PROTECTED = new(:protected)
-        PRIVATE = new(:private)
-      end
-    end
+    #: Configuration
+    attr_reader :configuration
 
     #: String
     attr_reader :name
@@ -22,31 +17,32 @@ module RubyIndexer
 
     alias_method :name_location, :location
 
-    #: Visibility
+    #: Symbol
     attr_accessor :visibility
 
-    #: (String name, URI::Generic uri, Location location, String? comments) -> void
-    def initialize(name, uri, location, comments)
+    #: (Configuration configuration, String name, URI::Generic uri, Location location, String? comments) -> void
+    def initialize(configuration, name, uri, location, comments)
+      @configuration = configuration
       @name = name
       @uri = uri
       @comments = comments
-      @visibility = Visibility::PUBLIC #: Visibility
+      @visibility = :public #: Symbol
       @location = location
     end
 
     #: -> bool
     def public?
-      visibility == Visibility::PUBLIC
+      @visibility == :public
     end
 
     #: -> bool
     def protected?
-      visibility == Visibility::PROTECTED
+      @visibility == :protected
     end
 
     #: -> bool
     def private?
-      visibility == Visibility::PRIVATE
+      @visibility == :private
     end
 
     #: -> String
@@ -90,7 +86,7 @@ module RubyIndexer
           correct_group.filter_map do |comment|
             content = comment.slice.chomp
 
-            if content.valid_encoding?
+            if content.valid_encoding? && !content.match?(@configuration.magic_comment_regex)
               content.delete_prefix!("#")
               content.delete_prefix!(" ")
               content
@@ -106,12 +102,8 @@ module RubyIndexer
       end
     end
 
+    # @abstract
     class ModuleOperation
-      extend T::Sig
-      extend T::Helpers
-
-      abstract!
-
       #: String
       attr_reader :module_name
 
@@ -124,12 +116,8 @@ module RubyIndexer
     class Include < ModuleOperation; end
     class Prepend < ModuleOperation; end
 
+    # @abstract
     class Namespace < Entry
-      extend T::Sig
-      extend T::Helpers
-
-      abstract!
-
       #: Array[String]
       attr_reader :nesting
 
@@ -137,13 +125,13 @@ module RubyIndexer
       #: Location
       attr_reader :name_location
 
-      #: (Array[String] nesting, URI::Generic uri, Location location, Location name_location, String? comments) -> void
-      def initialize(nesting, uri, location, name_location, comments)
+      #: (Configuration configuration, Array[String] nesting, URI::Generic uri, Location location, Location name_location, String? comments) -> void
+      def initialize(configuration, nesting, uri, location, name_location, comments) # rubocop:disable Metrics/ParameterLists
         @name = nesting.join("::") #: String
         # The original nesting where this namespace was discovered
         @nesting = nesting
 
-        super(@name, uri, location, comments)
+        super(configuration, @name, uri, location, comments)
 
         @name_location = name_location
       end
@@ -176,9 +164,9 @@ module RubyIndexer
       #: String?
       attr_reader :parent_class
 
-      #: (Array[String] nesting, URI::Generic uri, Location location, Location name_location, String? comments, String? parent_class) -> void
-      def initialize(nesting, uri, location, name_location, comments, parent_class) # rubocop:disable Metrics/ParameterLists
-        super(nesting, uri, location, name_location, comments)
+      #: (Configuration configuration, Array[String] nesting, URI::Generic uri, Location location, Location name_location, String? comments, String? parent_class) -> void
+      def initialize(configuration, nesting, uri, location, name_location, comments, parent_class) # rubocop:disable Metrics/ParameterLists
+        super(configuration, nesting, uri, location, name_location, comments)
         @parent_class = parent_class
       end
 
@@ -201,12 +189,8 @@ module RubyIndexer
     class Constant < Entry
     end
 
+    # @abstract
     class Parameter
-      extend T::Helpers
-      extend T::Sig
-
-      abstract!
-
       # Name includes just the name of the parameter, excluding symbols like splats
       #: Symbol
       attr_reader :name
@@ -300,24 +284,23 @@ module RubyIndexer
       end
     end
 
+    # @abstract
     class Member < Entry
-      extend T::Sig
-      extend T::Helpers
-
-      abstract!
-
       #: Entry::Namespace?
       attr_reader :owner
 
-      #: (String name, URI::Generic uri, Location location, String? comments, Visibility visibility, Entry::Namespace? owner) -> void
-      def initialize(name, uri, location, comments, visibility, owner) # rubocop:disable Metrics/ParameterLists
-        super(name, uri, location, comments)
+      #: (Configuration configuration, String name, URI::Generic uri, Location location, String? comments, Symbol visibility, Entry::Namespace? owner) -> void
+      def initialize(configuration, name, uri, location, comments, visibility, owner) # rubocop:disable Metrics/ParameterLists
+        super(configuration, name, uri, location, comments)
         @visibility = visibility
         @owner = owner
       end
 
-      sig { abstract.returns(T::Array[Entry::Signature]) }
-      def signatures; end
+      # @abstract
+      #: -> Array[Signature]
+      def signatures
+        raise AbstractMethodInvokedError
+      end
 
       #: -> String
       def decorated_parameters
@@ -354,6 +337,7 @@ module RubyIndexer
     end
 
     class Method < Member
+      # @override
       #: Array[Signature]
       attr_reader :signatures
 
@@ -361,9 +345,9 @@ module RubyIndexer
       #: Location
       attr_reader :name_location
 
-      #: (String name, URI::Generic uri, Location location, Location name_location, String? comments, Array[Signature] signatures, Visibility visibility, Entry::Namespace? owner) -> void
-      def initialize(name, uri, location, name_location, comments, signatures, visibility, owner) # rubocop:disable Metrics/ParameterLists
-        super(name, uri, location, comments, visibility, owner)
+      #: (Configuration configuration, String name, URI::Generic uri, Location location, Location name_location, String? comments, Array[Signature] signatures, Symbol visibility, Entry::Namespace? owner) -> void
+      def initialize(configuration, name, uri, location, name_location, comments, signatures, visibility, owner) # rubocop:disable Metrics/ParameterLists
+        super(configuration, name, uri, location, comments, visibility, owner)
         @signatures = signatures
         @name_location = name_location
       end
@@ -386,9 +370,9 @@ module RubyIndexer
       #: Array[String]
       attr_reader :nesting
 
-      #: (String target, Array[String] nesting, String name, URI::Generic uri, Location location, String? comments) -> void
-      def initialize(target, nesting, name, uri, location, comments) # rubocop:disable Metrics/ParameterLists
-        super(name, uri, location, comments)
+      #: (Configuration configuration, String target, Array[String] nesting, String name, URI::Generic uri, Location location, String? comments) -> void
+      def initialize(configuration, target, nesting, name, uri, location, comments) # rubocop:disable Metrics/ParameterLists
+        super(configuration, name, uri, location, comments)
 
         @target = target
         @nesting = nesting
@@ -403,6 +387,7 @@ module RubyIndexer
       #: (String target, UnresolvedConstantAlias unresolved_alias) -> void
       def initialize(target, unresolved_alias)
         super(
+          unresolved_alias.configuration,
           unresolved_alias.name,
           unresolved_alias.uri,
           unresolved_alias.location,
@@ -422,9 +407,9 @@ module RubyIndexer
       #: Entry::Namespace?
       attr_reader :owner
 
-      #: (String name, URI::Generic uri, Location location, String? comments, Entry::Namespace? owner) -> void
-      def initialize(name, uri, location, comments, owner)
-        super(name, uri, location, comments)
+      #: (Configuration configuration, String name, URI::Generic uri, Location location, String? comments, Entry::Namespace? owner) -> void
+      def initialize(configuration, name, uri, location, comments, owner) # rubocop:disable Metrics/ParameterLists
+        super(configuration, name, uri, location, comments)
         @owner = owner
       end
     end
@@ -434,9 +419,9 @@ module RubyIndexer
       #: Entry::Namespace?
       attr_reader :owner
 
-      #: (String name, URI::Generic uri, Location location, String? comments, Entry::Namespace? owner) -> void
-      def initialize(name, uri, location, comments, owner)
-        super(name, uri, location, comments)
+      #: (Configuration configuration, String name, URI::Generic uri, Location location, String? comments, Entry::Namespace? owner) -> void
+      def initialize(configuration, name, uri, location, comments, owner) # rubocop:disable Metrics/ParameterLists
+        super(configuration, name, uri, location, comments)
         @owner = owner
       end
     end
@@ -451,9 +436,9 @@ module RubyIndexer
       #: Entry::Namespace?
       attr_reader :owner
 
-      #: (String new_name, String old_name, Entry::Namespace? owner, URI::Generic uri, Location location, String? comments) -> void
-      def initialize(new_name, old_name, owner, uri, location, comments) # rubocop:disable Metrics/ParameterLists
-        super(new_name, uri, location, comments)
+      #: (Configuration configuration, String new_name, String old_name, Entry::Namespace? owner, URI::Generic uri, Location location, String? comments) -> void
+      def initialize(configuration, new_name, old_name, owner, uri, location, comments) # rubocop:disable Metrics/ParameterLists
+        super(configuration, new_name, uri, location, comments)
 
         @new_name = new_name
         @old_name = old_name
@@ -476,6 +461,7 @@ module RubyIndexer
         full_comments << target.comments
 
         super(
+          unresolved_alias.configuration,
           unresolved_alias.new_name,
           unresolved_alias.uri,
           unresolved_alias.location,
@@ -563,7 +549,8 @@ module RubyIndexer
         end
 
         keyword_hash_nodes, positional_args = arguments.partition { |arg| arg.is_a?(Prism::KeywordHashNode) }
-        keyword_args = T.cast(keyword_hash_nodes.first, T.nilable(Prism::KeywordHashNode))&.elements
+        keyword_args = keyword_hash_nodes.first #: as Prism::KeywordHashNode?
+          &.elements
         forwarding_arguments, positionals = positional_args.partition do |arg|
           arg.is_a?(Prism::ForwardingArgumentsNode)
         end

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

@@ -36,12 +36,10 @@ module RubyIndexer
 
       # Returns the unresolved name for a constant reference including all parts of a constant path, or `nil` if the
       # constant contains dynamic or incomplete parts
-      #: ((Prism::ConstantPathNode | Prism::ConstantReadNode | Prism::ConstantPathTargetNode | Prism::CallNode | Prism::MissingNode) node) -> String?
+      #: (Prism::Node) -> String?
       def constant_name(node)
         case node
-        when Prism::CallNode, Prism::MissingNode
-          nil
-        else
+        when Prism::ConstantPathNode, Prism::ConstantReadNode, Prism::ConstantPathTargetNode
           node.full_name
         end
       rescue Prism::ConstantPathNode::DynamicPartsInConstantPathError,
@@ -60,7 +58,7 @@ module RubyIndexer
       @entries = {} #: Hash[String, Array[Entry]]
 
       # Holds all entries in the index using a prefix tree for searching based on prefixes to provide autocompletion
-      @entries_tree = PrefixTree[T::Array[Entry]].new #: PrefixTree[Array[Entry]]
+      @entries_tree = PrefixTree.new #: PrefixTree[Array[Entry]]
 
       # Holds references to where entries where discovered so that we can easily delete them
       # {
@@ -71,7 +69,7 @@ module RubyIndexer
       @uris_to_entries = {} #: Hash[String, Array[Entry]]
 
       # Holds all require paths for every indexed item so that we can provide autocomplete for requires
-      @require_paths_tree = PrefixTree[URI::Generic].new #: PrefixTree[URI::Generic]
+      @require_paths_tree = PrefixTree.new #: PrefixTree[URI::Generic]
 
       # Holds the linearized ancestors list for every namespace
       @ancestors = {} #: Hash[String, Array[String]]
@@ -147,7 +145,7 @@ module RubyIndexer
 
     # Searches for a constant based on an unqualified name and returns the first possible match regardless of whether
     # there are more possible matching entries
-    #: (String name) -> Array[(Entry::Namespace | Entry::ConstantAlias | Entry::UnresolvedConstantAlias | Entry::Constant)]?
+    #: (String name) -> Array[Entry::Constant | Entry::ConstantAlias | Entry::Namespace | Entry::UnresolvedConstantAlias]?
     def first_unqualified_const(name)
       # Look for an exact match first
       _name, entries = @entries.find do |const_name, _entries|
@@ -161,15 +159,7 @@ module RubyIndexer
         end
       end
 
-      T.cast(
-        entries,
-        T.nilable(T::Array[T.any(
-          Entry::Namespace,
-          Entry::ConstantAlias,
-          Entry::UnresolvedConstantAlias,
-          Entry::Constant,
-        )]),
-      )
+      entries #: as Array[Entry::Constant | Entry::ConstantAlias | Entry::Namespace | Entry::UnresolvedConstantAlias]?
     end
 
     # Searches entries in the index based on an exact prefix, intended for providing autocomplete. All possible matches
@@ -205,12 +195,13 @@ module RubyIndexer
     end
 
     # Fuzzy searches index entries based on Jaro-Winkler similarity. If no query is provided, all entries are returned
-    #: (String? query) -> Array[Entry]
-    def fuzzy_search(query)
+    #: (String? query) ?{ (Entry) -> bool? } -> Array[Entry]
+    def fuzzy_search(query, &condition)
       unless query
         entries = @entries.filter_map do |_name, entries|
           next if entries.first.is_a?(Entry::SingletonClass)
 
+          entries = entries.select(&condition) if condition
           entries
         end
 
@@ -222,6 +213,9 @@ module RubyIndexer
       results = @entries.filter_map do |name, entries|
         next if entries.first.is_a?(Entry::SingletonClass)
 
+        entries = entries.select(&condition) if condition
+        next if entries.empty?
+
         similarity = DidYouMean::JaroWinkler.distance(name.gsub("::", "").downcase, normalized_query)
         [entries, -similarity] if similarity > ENTRY_SIMILARITY_THRESHOLD
       end
@@ -272,19 +266,11 @@ module RubyIndexer
       completion_items.values.map!(&:first)
     end
 
-    #: (String name, Array[String] nesting) -> Array[Array[(Entry::Constant | Entry::ConstantAlias | Entry::Namespace | Entry::UnresolvedConstantAlias)]]
+    #: (String name, Array[String] nesting) -> Array[Array[Entry::Constant | Entry::ConstantAlias | Entry::Namespace | Entry::UnresolvedConstantAlias]]
     def constant_completion_candidates(name, nesting)
       # If we have a top level reference, then we don't need to include completions inside the current nesting
       if name.start_with?("::")
-        return T.cast(
-          @entries_tree.search(name.delete_prefix("::")),
-          T::Array[T::Array[T.any(
-            Entry::Constant,
-            Entry::ConstantAlias,
-            Entry::Namespace,
-            Entry::UnresolvedConstantAlias,
-          )]],
-        )
+        return @entries_tree.search(name.delete_prefix("::")) #: as Array[Array[Entry::Constant | Entry::ConstantAlias | Entry::Namespace | Entry::UnresolvedConstantAlias]]
       end
 
       # Otherwise, we have to include every possible constant the user might be referring to. This is essentially the
@@ -309,16 +295,19 @@ module RubyIndexer
 
       # Top level constants
       entries.concat(@entries_tree.search(name))
+
+      # Filter only constants since methods may have names that look like constants
+      entries.select! do |definitions|
+        definitions.select! do |entry|
+          entry.is_a?(Entry::Constant) || entry.is_a?(Entry::ConstantAlias) ||
+            entry.is_a?(Entry::Namespace) || entry.is_a?(Entry::UnresolvedConstantAlias)
+        end
+
+        definitions.any?
+      end
+
       entries.uniq!
-      T.cast(
-        entries,
-        T::Array[T::Array[T.any(
-          Entry::Constant,
-          Entry::ConstantAlias,
-          Entry::Namespace,
-          Entry::UnresolvedConstantAlias,
-        )]],
-      )
+      entries #: as Array[Array[Entry::Constant | Entry::ConstantAlias | Entry::Namespace | Entry::UnresolvedConstantAlias]]
     end
 
     # Resolve a constant to its declaration based on its name and the nesting where the reference was found. Parameter
@@ -328,7 +317,7 @@ module RubyIndexer
     # nesting: the nesting structure where the reference was found (e.g.: ["Foo", "Bar"])
     # seen_names: this parameter should not be used by consumers of the api. It is used to avoid infinite recursion when
     # resolving circular references
-    #: (String name, Array[String] nesting, ?Array[String] seen_names) -> Array[(Entry::Namespace | Entry::ConstantAlias | Entry::UnresolvedConstantAlias)]?
+    #: (String name, Array[String] nesting, ?Array[String] seen_names) -> Array[Entry::Constant | Entry::ConstantAlias | Entry::Namespace | Entry::UnresolvedConstantAlias]?
     def resolve(name, nesting, seen_names = [])
       # If we have a top level reference, then we just search for it straight away ignoring the nesting
       if name.start_with?("::")
@@ -439,7 +428,10 @@ module RubyIndexer
       (parts.length - 1).downto(0) do |i|
         current_name = parts[0..i] #: as !nil
           .join("::")
-        entry = @entries[current_name]&.first
+
+        entry = unless seen_names.include?(current_name)
+          @entries[current_name]&.first
+        end
 
         case entry
         when Entry::ConstantAlias
@@ -586,7 +578,7 @@ module RubyIndexer
     # and find inherited instance variables as well
     #: (String variable_name, String owner_name) -> Array[Entry::InstanceVariable]?
     def resolve_instance_variable(variable_name, owner_name)
-      entries = T.cast(self[variable_name], T.nilable(T::Array[Entry::InstanceVariable]))
+      entries = self[variable_name] #: as Array[Entry::InstanceVariable]?
       return unless entries
 
       ancestors = linearized_ancestors_of(owner_name)
@@ -610,7 +602,7 @@ module RubyIndexer
     # include the `@` prefix
     #: (String name, String owner_name) -> Array[(Entry::InstanceVariable | Entry::ClassVariable)]
     def instance_variable_completion_candidates(name, owner_name)
-      entries = T.cast(prefix_search(name).flatten, T::Array[T.any(Entry::InstanceVariable, Entry::ClassVariable)])
+      entries = prefix_search(name).flatten #: as Array[Entry::InstanceVariable | Entry::ClassVariable]
       # Avoid wasting time linearizing ancestors if we didn't find anything
       return entries if entries.empty?
 
@@ -640,7 +632,7 @@ module RubyIndexer
 
     #: (String name, String owner_name) -> Array[Entry::ClassVariable]
     def class_variable_completion_candidates(name, owner_name)
-      entries = T.cast(prefix_search(name).flatten, T::Array[Entry::ClassVariable])
+      entries = prefix_search(name).flatten #: as Array[Entry::ClassVariable]
       # Avoid wasting time linearizing ancestors if we didn't find anything
       return entries if entries.empty?
 
@@ -676,19 +668,22 @@ module RubyIndexer
       # indirect means like including a module that than includes the ancestor. Trying to figure out exactly which
       # ancestors need to be deleted is too expensive. Therefore, if any of the namespace entries has a change to their
       # ancestor hash, we clear all ancestors and start linearizing lazily again from scratch
-      original_map = T.cast(
-        original_entries.select { |e| e.is_a?(Entry::Namespace) },
-        T::Array[Entry::Namespace],
-      ).to_h { |e| [e.name, e.ancestor_hash] }
+      original_map = original_entries
+        .select { |e| e.is_a?(Entry::Namespace) } #: as Array[Entry::Namespace]
+        .to_h { |e| [e.name, e.ancestor_hash] }
 
-      updated_map = T.cast(
-        updated_entries.select { |e| e.is_a?(Entry::Namespace) },
-        T::Array[Entry::Namespace],
-      ).to_h { |e| [e.name, e.ancestor_hash] }
+      updated_map = updated_entries
+        .select { |e| e.is_a?(Entry::Namespace) } #: as Array[Entry::Namespace]
+        .to_h { |e| [e.name, e.ancestor_hash] }
 
       @ancestors.clear if original_map.any? { |name, hash| updated_map[name] != hash }
     end
 
+    #: -> void
+    def clear_ancestors
+      @ancestors.clear
+    end
+
     #: -> bool
     def empty?
       @entries.empty?
@@ -713,12 +708,13 @@ module RubyIndexer
     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))
+      singleton = self[full_singleton_name]&.first #: as Entry::SingletonClass?
 
       unless singleton
         attached_ancestor = self[name]&.first #: as !nil
 
         singleton = Entry::SingletonClass.new(
+          @configuration,
           [full_singleton_name],
           attached_ancestor.uri,
           attached_ancestor.location,
@@ -841,14 +837,22 @@ module RubyIndexer
     )
       # Find the first class entry that has a parent class. Notice that if the developer makes a mistake and inherits
       # from two different 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),
-      )
+      possible_parents = singleton_levels > 0 ? self[attached_class_name] : namespace_entries
+      superclass = nil #: Entry::Class?
+
+      possible_parents&.each do |n|
+        # Ignore non class entries
+        next unless n.is_a?(Entry::Class)
+
+        parent_class = n.parent_class
+        next unless parent_class
+
+        # Always set the superclass, but break early if we found one that isn't `::Object` (meaning we found an explicit
+        # parent class and not the implicit default). Note that when setting different parents to the same class, which
+        # is invalid, we pick whatever is the first one we find
+        superclass = n
+        break if parent_class != "::Object"
+      end
 
       if superclass
         # If the user makes a mistake and creates a class that inherits from itself, this method would throw a stack
@@ -882,7 +886,7 @@ module RubyIndexer
       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))
+        mod = self[attached_class_name]&.find { |n| n.is_a?(Entry::Module) } #: as Entry::Module?
 
         if mod
           module_class_name_parts = ["Module"]
@@ -908,6 +912,9 @@ module RubyIndexer
       target = resolve(entry.target, entry.nesting, seen_names)
       return entry unless target
 
+      # Self referential alias can be unresolved we should bail out from resolving
+      return entry if target.first == entry
+
       target_name = target.first #: as !nil
         .name
       resolved_alias = Entry::ConstantAlias.new(target_name, entry)
@@ -922,7 +929,7 @@ module RubyIndexer
       resolved_alias
     end
 
-    #: (String name, Array[String] nesting, Array[String] seen_names) -> Array[(Entry::Namespace | Entry::ConstantAlias | Entry::UnresolvedConstantAlias)]?
+    #: (String name, Array[String] nesting, Array[String] seen_names) -> Array[Entry::Constant | Entry::ConstantAlias | Entry::Namespace | Entry::UnresolvedConstantAlias]?
     def lookup_enclosing_scopes(name, nesting, seen_names)
       nesting.length.downto(1) do |i|
         namespace = nesting[0...i] #: as !nil
@@ -942,7 +949,7 @@ module RubyIndexer
       nil
     end
 
-    #: (String name, Array[String] nesting, Array[String] seen_names) -> Array[(Entry::Namespace | Entry::ConstantAlias | Entry::UnresolvedConstantAlias)]?
+    #: (String name, Array[String] nesting, Array[String] seen_names) -> Array[Entry::Constant | Entry::ConstantAlias | Entry::Namespace | Entry::UnresolvedConstantAlias]?
     def lookup_ancestor_chain(name, nesting, seen_names)
       *nesting_parts, constant_name = build_non_redundant_full_name(name, nesting).split("::")
       return if nesting_parts.empty?
@@ -1023,22 +1030,25 @@ module RubyIndexer
       # Otherwise, push all of the leading parts of the nesting that aren't redundant into the name. For example, if we
       # have a reference to `Foo::Bar` inside the `[Namespace, Foo]` nesting, then only the `Foo` part is redundant, but
       # we still need to include the `Namespace` part
-      T.unsafe(name_parts).unshift(*nesting[0...first_redundant_part])
+      name_parts.unshift(*nesting[0...first_redundant_part])
       name_parts.join("::")
     end
 
-    #: (String full_name, Array[String] seen_names) -> Array[(Entry::Namespace | Entry::ConstantAlias | Entry::UnresolvedConstantAlias)]?
+    # Tries to return direct entry from index then non seen canonicalized alias or nil
+    #: (String full_name, Array[String] seen_names) -> Array[Entry::Constant | Entry::ConstantAlias | Entry::Namespace | Entry::UnresolvedConstantAlias]?
     def direct_or_aliased_constant(full_name, seen_names)
-      entries = @entries[full_name] || @entries[follow_aliased_namespace(full_name)]
-
-      T.cast(
-        entries&.map { |e| e.is_a?(Entry::UnresolvedConstantAlias) ? resolve_alias(e, seen_names) : e },
-        T.nilable(T::Array[T.any(
-          Entry::Namespace,
-          Entry::ConstantAlias,
-          Entry::UnresolvedConstantAlias,
-        )]),
-      )
+      if (entries = @entries[full_name])
+        return entries.map do |e|
+          e.is_a?(Entry::UnresolvedConstantAlias) ? resolve_alias(e, seen_names) : e
+        end #: as Array[Entry::Constant | Entry::ConstantAlias | Entry::Namespace | Entry::UnresolvedConstantAlias])?
+      end
+
+      aliased = follow_aliased_namespace(full_name, seen_names)
+      return if full_name == aliased || seen_names.include?(aliased)
+
+      @entries[aliased]&.map do |e|
+        e.is_a?(Entry::UnresolvedConstantAlias) ? resolve_alias(e, seen_names) : e
+      end #: as Array[Entry::Constant | Entry::ConstantAlias | Entry::Namespace | Entry::UnresolvedConstantAlias])?
     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/prefix_tree.rb

@@ -32,14 +32,14 @@ module RubyIndexer
   # `Value` type.
   #
   # See https://en.wikipedia.org/wiki/Trie for more information
+  #: [Value]
   class PrefixTree
-    extend T::Generic
-
-    Value = type_member
-
     #: -> void
     def initialize
-      @root = Node.new("", "") #: Node[Value]
+      @root = Node.new(
+        "",
+        "", #: as untyped
+      ) #: Node[Value]
     end
 
     # Search the PrefixTree based on a given `prefix`. If `foo` is an entry in the tree, then searching for `fo` will
@@ -106,11 +106,8 @@ module RubyIndexer
       node
     end
 
+    #: [Value]
     class Node
-      extend T::Generic
-
-      Value = type_member
-
       #: Hash[String, Node[Value]]
       attr_reader :children