Uma classe base pode mudar save() para persist() e deixar uma subclasse com um método save() que já não sobrescreve nada. O TypeScript ainda pode compilar esse código, porque a subclasse apenas ganhou um método próprio com um nome que ninguém chama pelo contrato da classe base.

noImplicitOverride fecha essa brecha. Quando a subclasse realmente substitui um membro herdado, ela precisa escrever override. Se o método da classe base for renomeado, o compilador aponta a divergência em vez de deixar uma sobrescrita silenciosa passar pela revisão.

Este artigo explica o mecanismo, mostra a diferença entre override e um método local e propõe uma migração curta com tsc --noEmit. A fixture foi compilada localmente com TypeScript 5.9.3 em 16 de novembro de 2026. Ela prova o diagnóstico do compilador em um exemplo mínimo, não o resultado de uma migração de produção.

Diagrama mostra uma renomeação na classe base sendo interrompida por override na subclasse.

Resposta curta

  • Ative noImplicitOverride quando a intenção de substituir métodos precisa aparecer no código.
  • Use override em todo membro que realmente substitui um membro da classe base.
  • Se um método deixou de sobrescrever depois de uma renomeação, corrija o contrato ou renomeie o helper. Não use as any para esconder o diagnóstico.
  • A opção verifica a relação entre classes. Ela não prova que a hierarquia é a melhor escolha para o domínio.

O que noImplicitOverride verifica?

O TypeScript verifica se um membro marcado com override existe na classe base e se a declaração pode substituí-lo. Com noImplicitOverride: true, também exige a palavra-chave quando a subclasse já está sobrescrevendo um membro herdado.

A referência oficial de noImplicitOverride usa uma classe Album e mostra o erro quando uma subclasse redefine um método sem o modificador. As notas do TypeScript 4.3 explicam o problema complementar: depois que um método é renomeado na classe base, uma subclasse pode continuar com o nome antigo sem que o compilador saiba que aquilo era uma sobrescrita pretendida.

O ponto importante é a intenção. O compilador não está dizendo que toda classe deve usar herança. Ele está pedindo que uma substituição seja declarada como substituição.

Por que uma renomeação pode passar sem a opção?

Considere esta hierarquia:

class Repository {
  save(value: string): string {
    return value;
  }
}

class AuditedRepository extends Repository {
  save(value: string): string {
    return `audit:${super.save(value)}`;
  }
}

O segundo save sobrescreve o primeiro. Agora a classe base muda por causa de uma decisão de nomenclatura:

class Repository {
  persist(value: string): string {
    return value;
  }
}

class AuditedRepository extends Repository {
  save(value: string): string {
    return `audit:${value}`;
  }
}

O método da subclasse ainda é válido como método TypeScript. O problema é semântico: chamadas feitas por uma referência Repository passaram a usar persist, enquanto a lógica de auditoria ficou em um método que o contrato base não conhece. O nome antigo não preserva a relação que existia antes.

Com override, a intenção fica presa ao contrato:

class AuditedRepository extends Repository {
  override save(value: string): string {
    return `audit:${super.save(value)}`;
  }
}

Depois que Repository.save vira Repository.persist, o compilador informa que o membro não existe na classe base. Esse erro é útil porque obriga a escolher entre override persist, um novo método local com outro nome ou uma mudança mais ampla na interface.

Como ativar a checagem no tsconfig.json?

Adicione a opção à configuração do projeto que compila a hierarquia:

{
  "compilerOptions": {
    "strict": true,
    "noImplicitOverride": true,
    "noEmit": true
  }
}

O valor não pertence ao conjunto de opções ativadas por strict. Por isso, um projeto pode usar strict: true e ainda aceitar uma sobrescrita sem override. A referência do TSConfig é a fonte para o comportamento da opção, enquanto o comando do seu projeto deve definir qual configuração realmente é usada no CI.

Se o repositório tem vários pacotes, não misture esta decisão com a ordem de compilação. Project References no TypeScript organizam o grafo de projetos; noImplicitOverride verifica a intenção dentro de cada classe. São problemas relacionados ao build, mas não são o mesmo contrato.

Quando usar override e quando renomear?

Use override quando o membro tem o mesmo papel do contrato herdado. O método pode envolver a chamada super, mudar a implementação ou acrescentar uma política, mas a relação com a classe base precisa ser real.

class JsonRepository extends Repository {
  override save(value: string): string {
    return JSON.stringify({ value: super.save(value) });
  }
}

Não use override em um helper que apenas recebeu um nome parecido por acaso. Se a classe base tem save() e a subclasse precisa de um saveForAuditLog(), nomes diferentes comunicam melhor a fronteira. Se os dois métodos têm o mesmo nome, a opção pode revelar uma herança que já estava difícil de entender.

Esse é um limite importante: o modificador prova a relação nominal com a classe base, não a qualidade do desenho. Uma classe ainda pode sobrescrever um método com efeitos incompatíveis, chamar super em uma ordem perigosa ou depender de uma pré-condição não documentada. Esses problemas pedem testes e revisão de contrato.

Como migrar uma hierarquia sem apagar o sinal?

Trate a ativação como uma mudança pequena no contrato do compilador:

  1. Rode o comando de typecheck que o CI usa hoje e guarde a configuração efetiva.
  2. Ative noImplicitOverride em um pacote ou projeto que tenha uma fronteira clara.
  3. Para cada diagnóstico, confirme se o membro deveria substituir a classe base.
  4. Adicione override quando a relação for intencional.
  5. Renomeie o método ou mude o contrato quando a relação não existir mais.
  6. Rode os testes que exercitam chamadas pela classe base, não apenas chamadas pela subclasse concreta.
  7. Mantenha a opção no CI para que uma renomeação futura produza um erro no mesmo conjunto de mudanças.

Uma fixture mínima para verificar o comportamento local é:

class Repository {
  save(value: string): string {
    return value;
  }
}

class AuditedRepository extends Repository {
  override save(value: string): string {
    return `audit:${super.save(value)}`;
  }

  formatLabel(value: string): string {
    return value.trim();
  }
}

const repository = new AuditedRepository();
console.log(repository.save("ready"));
console.log(repository.formatLabel(" label "));

Salve o trecho em um projeto isolado, use strict, noImplicitOverride, noEmit e types: [], e execute npx -p typescript@5.9.3 tsc -p tsconfig.json --pretty false. A fixture passa. Se você renomear save na classe base sem atualizar a subclasse, o modificador override produz TS4113. Isso confirma a fronteira da configuração, mas não substitui os testes do pacote real. Quando a mudança também altera o caminho de erro de um serviço, Result ou exception em um service TypeScript trata essa decisão separadamente.

O que não corrige o problema?

Há alguns atalhos que deixam o build verde sem preservar a intenção:

  • remover override de todos os métodos, eliminando justamente o vínculo que a opção documenta;
  • usar as any, as unknown as ou outra asserção para fazer um membro parecer compatível;
  • desligar noImplicitOverride no pacote inteiro porque um diagnóstico exige uma decisão;
  • adicionar override sem revisar se a classe base continua oferecendo o comportamento que a subclasse precisa.

Uma asserção pode ter lugar em uma fronteira que o compilador não consegue provar, mas não é uma resposta para uma renomeação que o código fonte consegue corrigir. satisfies para configs TypeScript cobre uma decisão parecida para valores escritos no código: verificar um contrato não é o mesmo que pedir ao compilador para confiar cegamente.

Se um agente de código altera a classe base e as subclasses na mesma tarefa, inclua no review a pergunta “o contrato mudou ou só a implementação?”. A validação de tool calls em TypeScript mostra uma fronteira complementar: o tipo estático não valida sozinho uma entrada que chegou em runtime. O RemoteCode é a ferramenta do autor para trabalhar com esse tipo de fluxo, mas a compilação e os testes continuam sendo a prova do repositório.

Perguntas frequentes

noImplicitOverride exige override em toda classe filha?

Não. Ele exige o modificador em membros que realmente sobrescrevem membros herdados. Um método novo, com nome que não existe na classe base, não precisa de override.

override funciona ao implementar uma interface?

O modificador descreve uma substituição em uma classe base. Implementar uma interface é outra relação de tipo e não deve ser tratado como uma sobrescrita de implementação. Se a classe também estende uma classe base, analise as duas relações separadamente.

Adicionar override muda o JavaScript executado?

Não por si só. O modificador participa da checagem do TypeScript e não é uma política de runtime. O comportamento ainda depende da cadeia de protótipos, do método chamado e dos testes que cobrem a chamada.

Fontes consultadas e limites

Samuel Fajreldines é o autor responsável por este artigo. A pesquisa comparou as referências oficiais do TypeScript com uma configuração pública de um projeto ativo. A fixture local passou com TypeScript 5.9.3 e falhou com TS4113 depois de uma renomeação deliberada na classe base. Isso demonstra o mecanismo em um caso mínimo, não a segurança de uma hierarquia de produção. A pesquisa, a redação, a localização e a revisão tiveram assistência de IA; a assistência não executou a fixture nem substitui as fontes ou a responsabilidade editorial do autor.