Prioritize and Differentiate Method Completions by Declaring Type

Summary

Improve Java IntelliSense in Visual Studio Code by prioritizing methods based on their declaring type and visually distinguishing methods declared in the current class from inherited ones.

---

Problem

When invoking code completion on an object, methods from the entire inheritance hierarchy (class, superclasses, interfaces) are presented in a flat, mostly alphabetical or heuristically ranked list.

This creates two issues:

• Hard to quickly identify methods defined in the current class
• No clear distinction between local vs inherited methods

---

Expected Behavior

1. Ordering by Declaring Type

Completion items should be grouped and ordered as follows:

1. Methods declared in the current class
2. Methods from direct superclasses
3. Methods from interfaces
4. Methods from deeper inheritance levels

Within each group, keep existing sorting (alphabetical or relevance-based).

---

2. Frequency-Based Promotion

• Frequently used methods may be promoted higher in the list
• However, usage-based ranking should not completely override structural grouping

---

3. Visual Differentiation

• Methods declared in the current class should be bolded
• (Optional) Other methods may include subtle indicators of their declaring type

---

Example (Class Inheritance)

class Base {
    void baseMethod() {}
}

interface MyInterface {
    void interfaceMethod() {}
}

class Derived extends Base implements MyInterface {
    void derivedMethod() {}
}

When invoking completion on Derived:

Expected order:

1. derivedMethod()
2. baseMethod()
3. interfaceMethod()

---

Example (Interface Inheritance)

interface BaseRepository<T> {
    void save(T entity);
}

interface PagingRepository<T> extends BaseRepository<T> {
    Iterable<T> findAll();
}

interface UserRepository extends PagingRepository<User> {
    User findByEmail(String email);
}

When invoking completion on UserRepository:

Expected order:

1. findByEmail(String email) // declared in UserRepository
2. findAll() // from PagingRepository
3. save(T entity) // from BaseRepository

---

Real-World Use Case

This is especially useful in frameworks like Spring Data / Hibernate, where repositories are composed via multiple interface layers.

For example:

• Developers primarily care about methods declared in their own repository interface
• Framework-provided methods (e.g., save, findAll) are secondary but still important

Improved ordering and highlighting would:

• Make custom query methods immediately visible
• Reduce cognitive load when working with large inherited APIs

---

Motivation

• Faster identification of relevant methods
• Better usability in deep inheritance hierarchies
• Clear distinction between user-defined and framework-provided methods
• Aligns with developer mental models

Im Issue sind keine Implementierungsdateien oder Tests angegeben. Beginne damit, die Einstiegspunkte für Java-Vervollständigungsrangfolge und die Darstellung von Vervollständigungselementen zu finden, und verfolge anschließend, wie deklarierende Typen und Vererbung dargestellt werden. Definiere die Reihenfolge der Vervollständigungen und visuelle Markierungen für aktuelle, direkt übergeordnete, Interface- und tieferliegende Methoden, und ergänze eine Abdeckung für Beispiele zur Vererbung von Klassen und Interfaces.