Hacktoberfest 2026: as issues que os mantenedores marcaram para outubro, abertas e boas para iniciantes. Ver issues do Hacktoberfest

Prioritize and Differentiate Method Completions by Declaring Type

Aberta
  • Algo errado?
#4,408 0 comentários 0 reações 0 responsáveis Ver no GitHub

Mantenedores costumam responder em até 1 dia

Ninguém assumiu esta issue ainda.

Avaliação

Dificuldade
5/5
Tempo estimado
Mais de uma semana
Facilidade para iniciantes
35/100
Tipo de issue
Funcionalidade
Clareza
Razoavelmente clara
Status de atividade
Pouca atividade
Stack de tecnologia
java, typescript
Domínio
developer-experience, tooling

Direção de pesquisa

Nenhum arquivo de implementação ou teste é identificado na issue. Comece localizando os pontos de entrada do ranking de conclusão Java e da apresentação de itens de conclusão; em seguida, rastreie como os tipos declarantes e a herança são representados. Defina a ordem das conclusões e os marcadores visuais para métodos atuais, de ancestral direto, de interface e de níveis mais profundos, e adicione cobertura para exemplos de herança de classes e interfaces.

Escrita pelo modelo de indexação a partir do texto da issue.

Descrição

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
Linguagem predominante
TypeScript
Estrelas
2.3k
Forks
549
Merge médio
8h 20min
PRs com merge (30d)
6

Preparar o ambiente

Primeiros passos

  1. Leia a issue inteira e depois o guia de contribuição do projeto.
  2. Comente na issue dizendo que vai assumir — evita que duas pessoas façam o mesmo trabalho.
  3. Faça um fork do repositório e trabalhe em uma branch.
  4. Abra um pull request que referencie o número da issue.

Mais de redhat-developer/vscode-java

Todas as issues de redhat-developer/vscode-java

Issues semelhantes

Mais issues de TypeScript

Receba novas issues na sua caixa de entrada

Um resumo curto de issues do GitHub para quem está começando.