lib/ruby_indexer/lib/ruby_indexer/index.rb in ruby-lsp-0.12.3 vs lib/ruby_indexer/lib/ruby_indexer/index.rb in ruby-lsp-0.12.4

@@ -91,12 +91,18 @@
     # [
     #   [#<Entry::Class name="Foo::Bar">, #<Entry::Class name="Foo::Bar">],
     #   [#<Entry::Class name="Foo::Baz">],
     # ]
     # ```
-    sig { params(query: String, nesting: T::Array[String]).returns(T::Array[T::Array[Entry]]) }
-    def prefix_search(query, nesting)
+    sig { params(query: String, nesting: T.nilable(T::Array[String])).returns(T::Array[T::Array[Entry]]) }
+    def prefix_search(query, nesting = nil)
+      unless nesting
+        results = @entries_tree.search(query)
+        results.uniq!
+        return results
+      end
+
       results = nesting.length.downto(0).flat_map do |i|
         prefix = T.must(nesting[0...i]).join("::")
         namespaced_query = prefix.empty? ? query : "#{prefix}::#{query}"
         @entries_tree.search(namespaced_query)
       end
@@ -178,12 +184,12 @@
 
     sig { params(indexable_path: IndexablePath, source: T.nilable(String)).void }
     def index_single(indexable_path, source = nil)
       content = source || File.read(indexable_path.full_path)
       result = Prism.parse(content)
-      visitor = IndexVisitor.new(self, result, indexable_path.full_path)
-      result.value.accept(visitor)
+      collector = Collector.new(self, result, indexable_path.full_path)
+      collector.collect(result.value)
 
       require_path = indexable_path.require_path
       @require_paths_tree.insert(require_path, indexable_path) if require_path
     rescue Errno::EISDIR
       # If `path` is a directory, just ignore it and continue indexing
@@ -227,9 +233,21 @@
           real_parts.unshift(T.must(parts[i]))
         end
       end
 
       real_parts.join("::")
+    end
+
+    # Attempts to find a given method for a resolved fully qualified receiver name. Returns `nil` if the method does not
+    # exist on that receiver
+    sig { params(method_name: String, receiver_name: String).returns(T.nilable(Entry::Method)) }
+    def resolve_method(method_name, receiver_name)
+      method_entries = T.cast(self[method_name], T.nilable(T::Array[Entry::Method]))
+      owner_entries = self[receiver_name]
+      return unless owner_entries && method_entries
+
+      owner_name = T.must(owner_entries.first).name
+      method_entries.find { |entry| entry.owner&.name == owner_name }
     end
 
     private
 
     # Attempts to resolve an UnresolvedAlias into a resolved Alias. If the unresolved alias is pointing to a constant