Prioritize and Differentiate Method Completions by Declaring Type

[milic-marko]

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