Anunciando o beta do null safety do Dart
Começando a jornada de migrar pacotes para um estado sólido e mais seguro
Publicado também aqui e no blog do Dart.
Hoje anunciamos que o null safety sólido já está disponível em beta para Dart e Flutter. O null safety é nossa mais recente funcionalidade de produtividade, criada para ajudar você a evitar erros de null, uma classe de bugs que costuma ser difícil de identificar. Se você quer um resumo rápido do motivo de estarmos animados com o null safety, confira este novo vídeo:
Com o null safety passando para beta, é hora de começar a migração da comunidade dos milhares de pacotes disponíveis no pub.dev. Migramos as bibliotecas core do Dart, o framework Flutter e mais de 40 pacotes do Dart e Flutter. Com isso, esperamos que a comunidade adote o null safety migrando seus pacotes.

Com a beta, também estamos chegando à reta final antes de lançar uma versão stable do recurso de null safety. Esperamos que você use o recurso e nos conte se partes dele podem melhorar, se as mensagens da UI podem ficar mais fáceis de entender ou se a documentação pode ficar mais clara. Estamos muito ansiosos pelo seu feedback.
Optando pelo null safety
Antes de falarmos sobre a migração para null safety, é importante reforçar que (como dito nos nossos princípios de null safety) você controla quando começar a adotar o null safety. Apps e pacotes só vão rodar com null safety se a restrição mínima de SDK do Dart for pelo menos um pré-lançamento do Dart 2.12:
environment:
sdk: ">=2.12.0-0 <3.0.0"
Para experimentar isso, tente criar um pequeno app hello com null safety (por exemplo, usando dart create) contendo um código como o mostrado abaixo. Depois, você pode rodar o app antes e depois de mudar a restrição de SDK e executar
dart pub get, e ver como o comportamento do programa muda. (Certifique-se de usar um SDK que informe 2.12 em
dart --version.)
No bin/hello.dart:
// ...
void main() {
var hello = 'Hello Dart developers';
if (someCondition) {
hello = null;
}
print(hello);
}
Antes de mudar a restrição de SDK, rode o app:
dart run
null
Depois de mudar a restrição de SDK e executar dart pub get,
rode o app novamente:
$ dart run
bin/hello.dart:6:13: Error: Null can't be assigned to a variable of type 'String' because 'String' is not nullable.
hello = null;
^
Migrando para o null safety
Para migrar um pacote (ou um app simples) para null safety, siga estes cinco passos, todos documentados no guia de migração em dart.dev.
Passo 1: Verifique se suas dependências estão prontas
Recomendamos fortemente migrar o código em ordem, começando pelas folhas do grafo de dependências. Por exemplo, se C depende de B, que depende de A, migre A para null safety primeiro, depois B e, por fim, C. Essa ordem vale se A, B e C forem bibliotecas, pacotes ou apps.

Por que a ordem é importante? Embora você possa avançar na migração do código antes que suas dependências migrem, corre o risco de precisar fazer uma segunda passada de migração caso as dependências mudem suas APIs durante a migração delas. Se algumas das suas dependências ainda não forem null safe, considere entrar em contato com os publicadores dos pacotes usando os dados de contato listados para cada pacote no pub.dev.
Verificando se as dependências estão prontas
Para verificar se seu app ou pacote está pronto para começar a migração, você pode usar dart pub outdated
em modo null-safety. O exemplo abaixo mostra que este app está pronto para migrar se atualizar suas dependências para as versões de pré-lançamento de
path, process e pedantic, conforme listado na coluna Resolvable
.

Se o suporte a null safety estiver disponível em versões menores mais novas, você verá essas versões na coluna Upgradable
. Com frequência, o suporte a null safety estará disponível em versões maiores mais novas; nesse caso, você verá as versões listadas em
Resolvable na saída de versões desatualizadas. Para atualizar para elas, edite seu arquivo pubspec.yaml
para permitir essas versões maiores. Por exemplo, você pode mudar
process: ^3.0.13 para process: ^4.0.0-nullsafety.
Você também pode encontrar pacotes com suporte a null safety no pub.dev usando as novas tags Null safety nas páginas dos pacotes (por exemplo, collection 1.15) e uma nova busca avançada opção de busca por null safety.

Passo 2: Migre usando a ferramenta de migração
Se suas dependências estiverem prontas, você pode migrar seu app ou pacote usando a ferramenta de migração,
dart migrate.
A ferramenta de migração é interativa, então você pode revisar as propriedades de nulabilidade que ela inferiu. Se discordar de alguma das conclusões da ferramenta, pode adicionar dicas de nulabilidade para mudar a inferência. Adicionar algumas dicas de migração pode ter um grande impacto na qualidade da migração.

Alguns autores de pacotes Dart testaram a migração usando versões de prévia iniciais do null safety, e o feedback deles foi encorajador. O guia de migração traz dicas adicionais sobre como usar a ferramenta de migração.
Passo 3: Faça a análise estática do código migrado
Atualize seus pacotes usando pub get no seu IDE ou na linha de comando. Depois, use seu IDE ou a linha de comando para fazer a análise estática do seu código Dart:
$ dart pub get
$ dart analyze
Ou no seu código Flutter:
$ flutter pub get
$ flutter analyze
Passo 4: Garanta que os testes passem
Execute seus testes e garanta que passem. Talvez você precise atualizar testes que esperam valores null, caso tenha mudado o código do pacote para não permitir mais nulls.
Passo 5: Publique seu pacote null safe
Quando a migração estiver concluída e os testes passarem, você pode publicar seu pacote como pré-lançamento. Aqui está um breve resumo das melhores práticas:
-
Incremente o número da versão para a próxima versão maior (por exemplo,
2.3.xpara3.0.0). Essa prática garante que os usuários do seu pacote não façam upgrade antes de estarem prontos para usar null safety, e dá a você liberdade para refatorar suas APIs e aproveitar melhor o null safety. -
Versione e publique seu pacote como uma versão de pré-lançamento no pub.dev. (Por exemplo, use
3.0.0-nullsafety.0, e não3.0.0.)
Para todos os detalhes sobre migração e versionamento, veja o guia de migração.
Os benefícios do null safety sólido
Nossos posts anteriores sobre as prévias técnicas do null safety no Dart e no Flutter discutiram os benefícios do null safety por meio de vários exemplos. Agora que o null safety está perto de ser concluído, estamos vendo vários exemplos reais desse benefício.
Código mais seguro
Recentemente, descobrimos um bug no canal master do Flutter em que vários comandos da ferramenta
flutter travavam em certas configurações de máquina com um erro de null: The method '>=' was called on null. A causa era um pull request recente para adicionar suporte à detecção do Android Studio 4.1. Esse PR adicionou código assim:
final int major = version?.major;
final int minor = version?.minor;
if (globals.platform.isMacOS) {
/// plugin path of Android Studio changed after version 4.1.
if (major >= 4 && minor >= 1) {
...
Consegue identificar o erro? Como a versão pode ser null, major e minor também podem ser null. Esse bug pode parecer fácil de notar isoladamente, mas na prática código assim passa despercebido o tempo todo, mesmo com um processo de code review rigoroso como o usado no repositório do Flutter. Com null safety, a análise estática detecta esse problema imediatamente:

Esse foi um erro bem simples. Durante nosso uso inicial de null safety em código interno no Google, vimos erros bem mais intrincados serem detectados e depois resolvidos com null safety. Aqui estão alguns exemplos:
-
Uma equipe interna descobriu que frequentemente verificava valores null em código que o null safety sabia que nunca poderia ser null. Esse problema era mais comum em código que usa protobuf, em que campos opcionais retornam um valor padrão quando não definidos, e nunca null. Isso fazia o código verificar incorretamente a condição padrão, confundindo valores padrão com valores null.
-
A equipe do Google Pay encontrou bugs no código Flutter deles em que falhavam ao tentar acessar objetos
Statedo Flutter fora do contexto de umWidget. Antes do null safety, esses acessos retornavam null e mascaravam o erro; com null safety, a análise sólida determinou que essas propriedades nunca poderiam ser null e gerou um erro de análise. -
A equipe do Flutter encontrou um bug em que a engine do Flutter poderia travar se null fosse passado para o parâmetro
sceneemWindow.render(). Durante a migração para null safety, eles adicionaram uma dica para marcar Scene como não anulável e, então, conseguiram prevenir facilmente possíveis travamentos do app que null causaria se fosse passado.
Aproveitando o null safety sólido durante a compilação
A solidez do null safety do Dart tem outra implicação bem-vinda: os compiladores do Dart podem aproveitar as informações de nulabilidade. Isso pode tornar seus programas menores e mais rápidos. Ainda não temos muitos apps reais totalmente migrados para o null safety sólido (já que estamos apenas começando a migração do ecossistema de pacotes dos quais esses apps dependem), mas estamos vendo resultados muito encorajadores no framework principal.
Recentemente, fizemos uma recompilação de teste do exemplo hello_world
para medir o impacto do null safety no tamanho do app. Este é um exemplo mínimo que simplesmente exibe “hello world”. Ao
comparar o tamanho geral do código compilado, o tamanho do código não comprimido (instalado no dispositivo) diminuiu 3,5% apenas por recompilar com null safety sólido. Isso foi possível, apesar de este app ter apenas 10 linhas de código, porque o tamanho de todas as bibliotecas incluídas diminuiu; por exemplo, o próprio framework Flutter (
package:flutter) diminuiu 3,9%.
Quanto à velocidade do código, ter que impor um sistema de tipos sólido pode adicionar overhead. No entanto, ter menos verificações de null também pode tornar o código mais rápido. Nossa análise inicial dos benchmarks mostra que o desempenho está no mesmo nível das versões anteriores, e que as novas informações de tipo criam o potencial para fazermos novos tipos de melhorias de desempenho no futuro. Planejamos escrever mais sobre nosso trabalho de desempenho em futuros posts do blog.
Em alguns casos, já vimos o null safety trazer ganhos de desempenho, normalmente quando a migração revelou uma falha na lógica do código. Por exemplo, encontramos um problema no cache de layout de texto da web do Flutter. Esse cache usava uma chave que era anulável e, então, havia uma lógica para usar
TextAlign.start quando o valor era null. Essa lógica causava uma falha no cache, em que elementos pareciam ter mudado mesmo ainda tendo um valor padrão. Como resultado, havia muitos cache misses. Adicionar um getter não anulável
textAlign ajudou a corrigir a falha de cache, resultando em um aumento de 14x
no desempenho da renderização de texto nos casos em que o texto está em cache.
Comece hoje mesmo!
As versões beta do Dart e do Flutter que contêm null safety já estão disponíveis. Se você desenvolve com Flutter, pode mudar para o beta com
flutter channel beta seguido de flutter upgrade. Caso contrário, você pode obter o SDK do Dart independente no arquivo do SDK do Dart.
Se você desenvolve pacotes, recomendamos que leia nosso guia de migração e planeje sua migração. Por favor, nos avise sobre quaisquer problemas ou sugestões que tiver.
Se você é desenvolvedor de apps, pode preferir adiar a migração até que o recurso esteja nos nossos canais stable. Planejamos tratar rapidamente o feedback do beta, corrigindo quaisquer problemas restantes. É difícil definir um prazo concreto para o null safety chegar a uma versão stable, mas estamos pensando no início do ano que vem.
Obrigado pelo seu apoio e feedback enquanto trabalhamos para tornar o Dart uma linguagem mais robusta e o Flutter um framework mais forte!
