Hacktoberfest 2026 : les issues que les mainteneurs ont marquées pour octobre, ouvertes et accessibles aux débutants. Parcourir les issues Hacktoberfest

Prioritize and Differentiate Method Completions by Declaring Type

Ouverte
  • Quelque chose ne va pas ?
#4,408 0 commentaires 0 réactions 0 personnes assignées Voir sur GitHub

Les mainteneurs répondent en général sous 1 jour

Personne n'a encore pris cette issue.

Évaluation

Difficulté
5/5
Temps estimé
Plus d'une semaine
Accessibilité débutants
35/100
Type d'issue
Fonctionnalité
Clarté
Plutôt claire
Activité
Calme
Stack technique
java, typescript
Domaine
developer-experience, tooling

Piste de recherche

Aucun fichier d’implémentation ni test n’est identifié dans l’issue. Commencez par localiser les points d’entrée du classement des complétions Java et de la présentation des éléments de complétion, puis suivez la manière dont les types déclarants et l’héritage sont représentés. Définissez l’ordre des complétions et les marqueurs visuels pour les méthodes actuelles, de l’ancêtre direct, d’interface et des niveaux d’héritage plus profonds, et ajoutez une couverture pour des exemples d’héritage de classes et d’interfaces.

Rédigé par le modèle d'indexation à partir du texte de l'issue.

Description

enhancement
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
Langage dominant
TypeScript
Étoiles
2.3k
Forks
547
Merge moyen
5 h 36 min
PR mergées (30 j)
10

Préparer son environnement

Par où commencer

  1. Lisez l'issue en entier, puis le guide de contribution du projet.
  2. Signalez en commentaire que vous la prenez — cela évite que deux personnes fassent le même travail.
  3. Forkez le dépôt et travaillez sur une branche.
  4. Ouvrez une pull request qui référence le numéro de l'issue.

Autres issues de redhat-developer/vscode-java

Toutes les issues de redhat-developer/vscode-java

Issues similaires

Plus d'issues TypeScript

Recevez les nouvelles issues par e-mail

Un résumé court des issues GitHub adaptées aux débutants.