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

No implementation files or tests are identified in the issue. Start by locating the Java completion-ranking and completion-item presentation entry points, then trace how declaring types and inheritance are represented. Define completion ordering and visual markers for current, direct ancestor, interface, and deeper methods, and add coverage for both class and interface inheritance examples.