Progresso no TypeScript 7 – Dezembro de 2025

Desenvolvimento
, ,
1

2 de dezembro de 2025

ts-logo-512
ts-logo-512512×512 1.72 KB

Progresso no TypeScript 7 – Dezembro de 2025

Daniel Rosenwasser

Gerente Principal de Produto

Sumário

No início deste ano, a equipe do TypeScript anunciou que está portando o compilador e o serviço de linguagem para código nativo para aproveitar melhor o desempenho bruto, uso de memória e paralelismo. Esse esforço (codinome “Projeto Corsa”, e em breve “TypeScript 7.0”) tem sido uma empreitada significativa, mas demos grandes passos nos últimos meses. Estamos animados em fornecer algumas atualizações sobre onde estamos e mostrar como o novo conjunto de ferramentas do TypeScript é real hoje.

Também temos notícias sobre nosso roadmap futuro e como estamos priorizando o trabalho no TypeScript 7.0 para levar nosso port à conclusão.

Suporte de Editor e Serviço de Linguagem

Para muitos desenvolvedores, uma reescrita de projeto pode parecer inteiramente teórica até ser finalmente lançada. Não é o caso aqui.

As prévias nativas do TypeScript são rápidas, estáveis e fáceis de usar hoje — inclusive em seu editor.

O serviço de linguagem do TypeScript (o que alimenta os recursos de TypeScript e JavaScript do seu editor) também é parte central do esforço de portagem nativa e é fácil de experimentar. Você pode obter a versão mais recente da Visual Studio Code Marketplace, que é atualizada diariamente.

Nossa equipe ainda está portando recursos e corrigindo bugs menores, mas a maior parte do que realmente compõe a experiência de edição existente do TypeScript já está lá e funcionando bem.

Isso inclui:

  • Completar código (incluindo auto-importações!)
  • Ir para Definição
  • Ir para Definição de Tipo
  • Ir para Implementação
  • Encontrar Todas as Referências
  • Renomear
  • Informações Rápidas/Dicas ao Passar o Mouse
  • Ajuda de Assinatura
  • Formatação
  • Intervalos de Seleção
  • Lentes de Código
  • Hierarquia de Chamadas
  • Símbolos do Documento
  • Correções Rápidas para Importações Ausentes

Você pode notar algumas coisas que se destacam desde nossa última grande atualização — auto-importações, encontrar todas as referências, renomear e mais. Sabemos que esses recursos eram as peças faltantes que impediam muitos desenvolvedores de experimentar as prévias nativas. Estamos felizes em dizer que esses recursos agora foram reimplementados e estão prontos para uso diário! Essas operações agora funcionam em qualquer base de código TypeScript ou JavaScript — incluindo aquelas com referências de projeto.

Também reestruturamos partes do nosso serviço de linguagem para melhorar a confiabilidade, aproveitando paralelismo de memória compartilhada. Embora algumas equipes tenham relatado que a experiência original era um pouco “instável” às vezes, muitas vezes aceitavam isso por causa das melhorias de velocidade. A nova arquitetura é mais robusta e deve ser capaz de lidar com bases de código, grandes e pequenas, sem problemas.

Embora certamente haja mais para portar e aprimorar, sua equipe provavelmente descobrirá que experimentar as prévias nativas do TypeScript vale a pena. Você pode esperar tempos de carregamento mais rápidos, menos uso de memória e um editor mais ágil/responsivo no geral.

Se você alguma vez ficar insatisfeito com a experiência, nossa extensão facilita alternar entre a experiência TypeScript integrada ao VS Code e a nova. Realmente encorajamos você e sua equipe a experimentar a extensão de prévia nativa para VS Code hoje!

Compilador

O compilador TypeScript também fez progressos significativos na portagem nativa. Assim como nossa extensão do VS Code, temos publicado compilações noturnas de prévia do novo compilador sob o nome do pacote @typescript/native-preview. Você pode instalá-lo via npm assim:

# dependência de desenvolvimento local
npm install -D @typescript/native-preview

# instalação global
npm install -g @typescript/native-preview

Esse pacote fornece um comando tsgo que funciona de maneira semelhante ao comando existente tsc. Os dois podem ser executados lado a lado.

Uma pergunta frequente que recebemos é se é “seguro” usar o TypeScript 7 para validar uma compilação; em outras palavras, ele encontra confiavelmente os mesmos erros que o TypeScript 5.9?

A resposta é um sim contundente. A verificação de tipos do TypeScript 7 está quase completa. Para contexto, temos cerca de 20.000 casos de teste do compilador, dos quais cerca de 6.000 produzem pelo menos um erro no TypeScript 6.0. Em todos, exceto 74 casos, o TypeScript 7 também produz pelo menos um erro. Dos 74 casos restantes, todos são trabalhos incompletos conhecidos (por exemplo, verificação de sintaxe de expressões regulares ou erros de isolatedDeclarations) ou estão relacionados a mudanças intencionais conhecidas (depreciações, mudanças de configurações padrão, etc.). Você pode usar confiantemente o TypeScript 7 hoje para verificar seu projeto quanto a erros.

Além da verificação de tipos de passagem única/projeto único, o compilador de linha de comando também alcançou grande paridade. Recursos como --incremental, suporte a referências de projeto e modo --build também foram portados e estão funcionando! Isso significa que a maioria dos projetos agora pode experimentar a prévia nativa com mudanças mínimas.

# Executando tsc em modo --build...
tsc -b some.tsconfig.json --extendedDiagnostics

# Executando o *novo compilador* em modo --build...
tsgo -b some.tsconfig.json --extendedDiagnostics

Não apenas esses recursos estão agora disponíveis, eles devem ser dramaticamente mais rápidos do que as versões existentes implementadas no TypeScript 5.9 e anteriores (conhecidas como “base de código Strada”). Como descrevemos anteriormente, isso se deve em parte ao desempenho do código nativo, mas também ao uso de paralelismo de memória compartilhada. Mais especificamente, isso significa que o TypeScript agora pode fazer compilações multithread rápidas em projetos únicos; ele também pode compilar vários projetos em paralelo! Combinado com nossa reimplementação de --incremental, estamos próximos de tornar as compilações do TypeScript quase instantâneas para pequenas alterações em projetos grandes.

Apenas como lembrete, mesmo sem --incremental, o TypeScript 7 frequentemente vê um aumento de velocidade próximo a 10x em relação ao compilador 6.0 em compilações completas!

Projeto tsc (6.0) tsgo (7.0) Delta Fator de Aceleração
sentry 133.08s 16.25s 116.84s 8.19x
vscode 89.11s 8.74s 80.37s 10.2x
typeorm 15.80s 1.06s 14.20s 9.88x
playwright 9.30s 1.24s 8.07s 7.51x

Diferenças Esperadas em Relação ao TypeScript 5.9

Há algumas ressalvas ao usar o novo compilador que queremos destacar. Muitas dessas são problemas pontuais que planejamos resolver antes do lançamento final da versão 7.0, mas algumas são impulsionadas por decisões de longo prazo para tornar a experiência padrão do TypeScript melhor. A promessa do TypeScript 7.0 significa que precisaremos mudar fortemente nosso foco para a nova base de código para fechar lacunas existentes e colocar a nova cadeia de ferramentas nas mãos de mais desenvolvedores. Mas vamos primeiro mergulhar e cobrir algumas das mudanças e limitações atuais.

Compatibilidade de Depreciação

O TypeScript 7.0 removerá comportamentos e flags que planejamos depreciar no TypeScript 6.0. Atualmente, você pode ver a lista de depreciações futuras no 6.0 em nosso rastreador de problemas. Alguns exemplos proeminentes incluem:

Isso não é abrangente, então confira o rastreador de problemas para o estado atual das coisas. Se seu projeto depender de qualquer um desses comportamentos depreciados, você pode precisar fazer algumas alterações em sua base de código ou tsconfig.json para garantir compatibilidade com o TypeScript 7.0.

Nossa equipe tem experimentado uma ferramenta chamada ts5to6 para ajudar a atualizar seu tsconfig.json automaticamente. A ferramenta usa heurísticas em extends e references para ajudar a atualizar outros projetos em sua base de código. Atualmente, ela só pode atualizar as configurações baseUrl e rootDir, mas mais podem ser adicionadas no futuro.

npx @andrewbranch/ts5to6 --fixBaseUrl seu-arquivo-tsconfig-aqui.json
npx @andrewbranch/ts5to6 --fixRootDir seu-arquivo-tsconfig-aqui.json

Emissão, --watch e API

Mesmo com a prontidão para 6.0, há algumas circunstâncias em que o novo compilador não pode ser imediatamente substituído.

Primeiro, o pipeline de emissão de JavaScript não está totalmente completo. Se você não precisar de emissão de JavaScript do TypeScript (por exemplo, se você usar Babel, esbuild ou algo semelhante), ou se estiver direcionando navegadores/runtimes modernos, executar tsgo para sua compilação funcionará bem. Mas se você depender do TypeScript para direcionar runtimes mais antigos, nosso suporte à compilação de nível inferior realista só vai até o alvo es2021, e sem suporte à compilação de decoradores. Planejamos resolver isso com suporte completo a --target retroativo até es2015, mas esse trabalho ainda está em andamento.

Outro problema é que nosso novo modo --watch pode ser menos eficiente do que o compilador TypeScript existente em alguns cenários. Em alguns casos, você pode encontrar outras soluções, como executar nodemon e tsgo com a flag --incremental.

Finalmente, Corsa/TypeScript 7.0 não suportará a API Strada existente. A API Corsa ainda está em desenvolvimento, e nenhuma integração de ferramentas estável existe para ela. Isso significa que quaisquer ferramentas como linters, formatadores ou extensões de IDE que dependam da API Strada não funcionarão com Corsa.

A solução alternativa para alguns desses problemas pode ser instalar os pacotes typescript e @typescript/native-preview lado a lado e usar a API ≤6.0 para ferramentas que precisam dela, com tsgo para verificação de tipos.

Verificação de JavaScript e Compatibilidade com JSDoc

Outra coisa que queremos destacar é que nosso suporte à verificação de tipos de JavaScript (parcialmente alimentado por anotações JSDoc) foi reescrito do zero. Em um esforço para simplificar nossos internos, reduzimos parte de nosso suporte a padrões complexos e menos usados que reconhecíamos e analisávamos anteriormente. Por exemplo, o TypeScript 7.0 não reconhece as tags @enum e @constructor. Também descartamos algumas regras de verificação de tipos “relaxadas” em JavaScript, como interpretar:

  • Object como any,
  • String como string,
  • Foo como typeof Foo quando o último teria sido válido em um arquivo TypeScript,
  • todos os parâmetros tipados como any, unknown e undefined como opcionais

e mais. Alguns desses estão sendo revisados e documentados aqui, embora a lista possa precisar ser atualizada.

Isso significa que algumas bases de código JavaScript podem ver mais erros do que antes e podem precisar ser atualizadas para funcionar bem com o novo compilador. Por outro lado, acreditamos que a nova implementação é mais robusta e mantida, e alinha o suporte JSDoc do TypeScript com sua própria sintaxe de tipos.

Se você sentir que algo deveria estar funcionando ou está faltando em nosso suporte à verificação de tipos de JavaScript, encorajamos você a abrir um problema em nosso repositório GitHub.

Focando no Futuro

Quando começamos a reescrever o TypeScript no ano passado, havia muitas incertezas. A comunidade ficaria animada? Quanto tempo levaria para a base de código estabilizar? Quão rapidamente as equipes poderiam adotar esse novo conjunto de ferramentas? Que grau de compatibilidade seríamos capazes de entregar?

Em todos os aspectos, ficamos muito agradavelmente surpresos. Conseguimos implementar um verificador de tipos com compatibilidade extremamente alta. Como resultado, projetos dentro e fora da Microsoft relatam que conseguiram usar facilmente o compilador nativo com esforço mínimo. A estabilidade está indo bem, e estamos no caminho certo para concluir a maioria dos recursos do serviço de linguagem até o final do ano. Muitas equipes já estão usando Corsa para trabalho diário sem problemas bloqueadores.

Com o 6.0 se aproximando, precisamos considerar o que acontecerá em seguida na base de código JavaScript. Nosso plano inicial era continuar o trabalho na linha 6.0 “até que o TypeScript 7+ atinja maturidade e adoção suficientes”. Sabemos que ainda há trabalho restante para desbloquear mais desenvolvedores (por exemplo, mais trabalho na superfície da API), e encerrar o desenvolvimento na linha Strada — nosso compilador baseado em JavaScript — é a melhor maneira de remover esses bloqueios mais cedo do que mais tarde. Para nos ajudar a concluir isso o mais rápido possível, estamos tomando algumas medidas no projeto Strada.

TypeScript 6.0 é a Última Versão Baseada em JavaScript

O TypeScript 6.0 será nosso último lançamento baseado na base de código TypeScript/JavaScript existente. Em outras palavras, não pretendemos lançar um TypeScript 6.1, embora possamos ter lançamentos de correção (por exemplo, 6.0.1, 6.0.2) em circunstâncias mais raras.

Você pode pensar no TypeScript 6.0 como um lançamento “ponte” entre a linha TypeScript 5.9 e 7.0. O 6.0 depreciará recursos para alinhar-se com o 7.0 e será altamente compatível em termos de comportamento de verificação de tipos.

A maioria das bases de código que precisam de funcionalidades específicas do Strada no lado do editor (por exemplo, plugins de serviço de linguagem) deve ser capaz de usar o 6.0 para funcionalidades do editor e o 7.0 para compilações rápidas em linha de comando sem muita dificuldade. O inverso também é verdadeiro: os desenvolvedores podem usar o 7.0 para uma experiência mais rápida em seu editor e o 6.0 para ferramentas em linha de comando que dependem da API TypeScript 6.0.

Serviços adicionais após o lançamento do TypeScript 6.0 serão na forma de lançamentos de correção e serão emitidos apenas em caso de:

  • problemas de segurança,
  • regressões de alta gravidade (ou seja, bugs novos e sérios que não estavam presentes no 5.9),
  • correções de alta gravidade relacionadas à compatibilidade entre 6.0/7.0.

Como nos lançamentos anteriores, os lançamentos de correção serão infrequentes e emitidos apenas quando absolutamente necessários.Mas, por enquanto, queremos garantir que o TypeScript 6.0 e 7.0 sejam o mais compatíveis possível. Manteremos um padrão muito alto em relação a quais PRs abertos serão mesclados na linha 6.0. Isso entra em vigor hoje e significa que a maioria dos desenvolvedores precisará ajustar suas expectativas sobre quais problemas serão abordados no TypeScript 6.0. Além disso, os colaboradores devem entender que é muito improvável que mesclamos pull requests no 6.0, já que a maior parte do nosso foco está em trazer o 7.0 à paridade e estabilidade. Queremos ser transparentes nesse aspecto para que não haja trabalho “desperdiçado” e para que nossa equipe possa evitar complicações ao portar alterações entre as duas bases de código.

Redefinindo problemas do Serviço de Linguagem

Embora a maior parte do código principal de verificação de tipos tenha sido portada sem diferenças comportamentais, o serviço de linguagem é uma história diferente. Dada a nova arquitetura, grande parte do código que alimenta conclusões, dicas ao passar o mouse, navegação e mais foi reescrita extensivamente. Além disso, o TypeScript 7.0 usa o protocolo padrão LSP em vez do protocolo personalizado TSServer, então algum comportamento específico à extensão TypeScript para VS Code pode ter mudado.

Como resultado, qualquer bug ou sugestão específico ao comportamento do serviço de linguagem provavelmente não será reproduzido na linha 7.0, ou precisará de um “reset” na conversa.

Esses problemas são muito demorados para serem verificados manualmente, então, em vez disso, vamos fechar problemas existentes relacionados ao comportamento do serviço de linguagem. Se você encontrar um problema que foi fechado com a etiqueta “7.0 LS Migration”, por favor registre um novo problema após validar que ele pode ser reproduzido na extensão nativa nightly. Para funcionalidades que ainda não foram portadas para o 7.0, por favor aguarde até que a funcionalidade esteja presente antes de abrir um novo problema.

O que vem a seguir?

Quando apresentamos nossas prévias nativas há alguns meses, tivemos que gerenciar as expectativas sobre o estado do projeto. Agora estamos em um ponto em que podemos afirmar com confiança que a experiência nativa do TypeScript é real, estável e pronta para uso mais amplo. Mas ainda estamos absolutamente em busca de feedback.

Portanto, incentivamos você a instalar a extensão de prévia nativa do VS Code, usar o pacote do compilador @typescript/native-preview sempre que possível e testá-lo em seus projetos. Nos diga o que você acha e registre problemas em nosso repositório do GitHub para nos ajudar a corrigir quaisquer problemas e priorizar o que trabalhar em seguida.

Estamos empolgados com o futuro do TypeScript e mal podemos esperar para colocar o TypeScript 7.0 em suas mãos!

Feliz codificação!