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

Issue 中没有确定实现文件或测试。首先定位 Java 补全排序和补全项展示的入口点，然后跟踪声明类型和继承的表示方式。定义当前方法、直接祖先方法、接口方法和更深层方法的补全顺序及视觉标记，并为类继承和接口继承示例添加覆盖。