Hot reload no Flutter

O que acontece durante um hot reload e como o tornamos mais rápido no Flutter 2.2.

O hot reload já era rápido no Flutter 2.0, mas ficou mais rápido no Flutter 2.2. Continue lendo para saber mais detalhes sobre o hot reload em geral e sobre como o tornamos mais rápido no Flutter 2.2.

Introdução

Um dos grandes recursos do Flutter é o hot reload. Você pressiona r no teclado e, alguns instantes depois, o impacto das suas mudanças aparece no dispositivo. No seu terminal (ou talvez na parte inferior da sua IDE) você pode ler algo como Reloaded 1 of 553 libraries in 297ms. Mas o que realmente acontece por trás dos panos quando você inicia um hot reload, e como as equipes do Dart e do Flutter conseguiram deixá-lo ainda mais rápido?

Visão geral de um hot reload

Um hot reload no Flutter consiste, grosso modo, nas seguintes cinco etapas:

  1. flutter_tools verifica os arquivos necessários em busca de mudanças. Ele analisa cada arquivo necessário e checa se o timestamp da última alteração é mais recente que o timestamp da compilação anterior.

  2. flutter_tools instrui um compilador Dart em execução a recompilar o app e informa quais arquivos mudaram. O compilador Dart recompila.

  3. flutter_tools envia os arquivos atualizados para o dispositivo. Isso inclui quaisquer assets alterados e o arquivo delta kernel recém-compilado (a saída da compilação, um arquivo que a Dart VM consegue entender).

  4. flutter_tools pede que todos os isolates na Dart VM do dispositivo recarreguem os seus códigos-fonte (para ler o arquivo delta kernel alterado e fazer a sua mágica).

  5. flutter_tools instrui o app no dispositivo a fazer reassemble, isto é, reconstruir todos os widgets na tela, recarregar os assets, refazer o layout, repintar etc.

Na minha máquina de desenvolvimento, com o dispositivo de destino sendo Linux (ou seja, um app desktop executado localmente), ao fazer o primeiro hot reload em um flutter create app recém-criado depois de atualizar apenas o timestamp do lib/main.dart arquivo, obtenho tempos como estes (extraídos de flutter run -v):

  1. A varredura dos arquivos leva cerca de 13 ms.

  2. A recompilação leva cerca de 67 ms.

  3. O envio dos arquivos para o dispositivo leva cerca de 2 ms.

  4. A Dart VM recarrega os códigos-fonte em cerca de 96 ms.

  5. O reassemble leva cerca de 114 ms.

Se eu tiver um app maior (e alterar outro arquivo), posso obter tempos como estes:

  1. A varredura dos arquivos leva cerca de 12 ms.

  2. A recompilação leva cerca de 386 ms.

  3. O envio dos arquivos para o dispositivo leva cerca de 2 ms.

  4. A Dart VM recarrega os códigos-fonte em cerca de 171 ms.

  5. O reassemble leva cerca de 229 ms.

Nos dois casos, as etapas a seguir são as que mais consomem tempo:

  • Recompilação

  • Recarregamento

  • Reassemble

Para tornar o hot reload mais rápido, precisamos tornar uma ou mais dessas três etapas mais rápidas.

Aqui vou me concentrar na primeira parte: recompilar os arquivos de código-fonte alterados para algo que a Dart VM consiga usar.

Recompilação

Logicamente, se eu, como usuário, altero um arquivo — digamos, foo.dart — eu esperaria que a recompilação funcionasse assim:

  1. O compilador tem o estado antigo na memória.

  2. O compilador é informado de que foo.dart mudou.

  3. O compilador descarta o seu estado interno para foo.dart.

  4. O compilador recompila foo.dart.

  5. Pronto.

Seria ótimo. Isso significaria que, qualquer que fosse o arquivo que eu alterasse, eu recompilaria apenas aquele arquivo e — presumivelmente — a recompilação seria rápida.

Infelizmente, a recompilação geralmente não funciona assim. Aqui estão dois exemplos de por que a recompilação pode não ser tão simples:

  • foo.dart costumava conter a classe Foo, que é usada em vários lugares. O arquivo alterado não contém mais essa classe (talvez tenha sido renomeada manualmente), e todos os arquivos que usam a classe deveriam gerar um erro de compilação.

  • foo.dart costumava ter um campo definido como var z = 42. Outro arquivo usa esse campo: var z2 = z * 2. A inferência de tipos do Dart concluiu que z era um inteiro e que z2 também era um inteiro, porque z era um. Agora o campo passou a ser var z = 42.2. Desta vez a inferência de tipos do Dart vai concluir que o campo é um double, mas, sem recompilar também a outra biblioteca, z2 continuará (incorretamente) marcado como inteiro.

Por causa disso, a recompilação no Dart há muito tempo funciona assim:

  1. O compilador tem o estado antigo na memória.

  2. O compilador é informado de que foo.dart mudou.

  3. O compilador descarta o seu estado interno para foo.dart.

  4. O compilador verifica quais arquivos importam ou exportam foo.dart e descarta esses também.

  5. O compilador verifica quais arquivos importam ou exportam os arquivos da etapa 4 e descarta esses também.

  6. E assim por diante: descarta todos os importadores e exportadores transitivos.

  7. O compilador recompila todas as bibliotecas (agora) “faltantes”.

  8. Pronto.

Isso pode parecer ruim, mas em muitos casos não é. Embora alterar o seu próprio conjunto de widgets personalizados possa resultar na recompilação de todo o código que você escreveu, isso não resulta na recompilação do próprio framework Flutter, por exemplo, porque o framework Flutter não importa nem exporta as suas bibliotecas. Por outro lado, se você alterar um arquivo central para o framework Flutter, acabará recompilando (quase) tudo.

Olhando de volta para a lista (incompleta) de motivos pelos quais recompilar apenas o arquivo alterado não funciona, podemos ver um padrão: não funciona porque você fez mudanças globais — mudanças que influenciam outras bibliotecas. Mas e se você tiver alterado apenas um comentário? Ou adicionado mais um debug-print ao seu método build? Ou corrigido um bug de off-by-one no seu método utilitário? Essas mudanças não são globais, e deveríamos conseguir fazer melhor!

Fazendo melhor

Para mudanças não globais — mudanças que não podem influenciar a compilação de outras bibliotecas — poderíamos, de fato, recompilar apenas a biblioteca alterada e ainda preservar a semântica. O principal problema é descobrir quando uma mudança é global e quando não é (e fazer isso rapidamente). Felizmente, isso pode ser feito em etapas incrementais: não precisamos acertar tudo de primeira (ou nunca).

Um primeiro passo seria comparar o arquivo como era com o arquivo como está agora, ignorando os comentários nas duas versões. Se, nessa comparação, as duas versões do arquivo forem iguais, concluímos que não houve mudanças globais e seguimos para recompilar apenas o arquivo alterado, em vez de todo o grafo transitivo de importação e exportação. Essa técnica não é perfeita. Por exemplo, ela ainda dispararia a recompilação de todos os importadores e exportadores transitivos ao corrigir aquele bug de off-by-one no seu método utilitário. Mas ela permitiria corrigir aquele erro de digitação nos seus comentários recompilando apenas esse arquivo.

Uma observação rápida: por que precisamos recompilar se estamos alterando apenas comentários? Principalmente por causa dos stack traces. Internamente, alguns nós (que representam o seu código) contêm offsets — informações sobre a posição deles no arquivo. Se essa informação ficar desatualizada, o seu stack trace conterá informações inválidas. Por exemplo, ele pode dizer que algo aconteceu na linha 42 quando, na verdade, não aconteceu.

Para chegar a um ponto em que você realmente possa corrigir aquele bug de off-by-one no seu método utilitário e ainda recompilar apenas esse arquivo, temos que ignorar mais uma coisa ao verificar mudanças globais: os corpos das funções. Novamente vamos comparar a versão antes e depois do arquivo alterado, desta vez ignorando comentários e corpos de funções. Se forem iguais, recompilaremos apenas esse arquivo.

Agora estamos de fato numa posição em que você pode fazer várias mudanças úteis sem recompilar mais do que o arquivo que alterou. Você pode adicionar, remover e alterar de outras formas os comentários. Pode adicionar (e remover) debug-prints nos seus métodos build. Pode até corrigir bugs nos seus métodos utilitários.

Boas notícias!

Acontece que essas melhorias na recompilação já foram feitas. Se você está usando o Flutter 2.2, talvez já tenha notado. Se não, talvez perceba agora. Para ser sincero, em apps pequenos você provavelmente não notará muita diferença, mas em apps maiores, sim.

Fiz alguns exemplos de mudanças não globais para medir o efeito.

Para o app de exemplo Veggie Seasons (um app relativamente pequeno):

  • Alterar lib/main.dart não traz melhoria. Antes compilava um arquivo e agora compila um arquivo.

  • Alterar lib/data/veggie.dart traz melhorias na faixa de 30%. O tempo real de compilação na minha máquina vai de mais de 100 ms para menos de 20 ms (antes compilava 18 arquivos, agora compila apenas 1). Isso é, naturalmente, muito mais que 30%, mas como a recompilação era apenas um dos três gargalos de tempo (os outros dois são o recarregamento e o reassemble), a mudança geral fica em torno de 30%.

Para o Flutter Gallery (um app relativamente grande):

  • Alterar lib/main.dart traz melhorias muito pequenas (compila 1 arquivo em vez de 2).

  • Alterar lib/layout/adaptive.dart reduz quase pela metade o tempo de recarregamento. O tempo só da recompilação vai de quase 400 ms para 40 ms (recompilando 1 arquivo em vez de 47).

Você deve esperar que os hot reloads no mundo real fiquem, em média, cerca de 30% mais rápidos no Flutter 2.2 do que eram no Flutter 2.0. Para colocar isso em perspectiva, essa mudança economiza, coletivamente, para as pessoas desenvolvedoras do Flutter, mais de um ano de espera pelo hot reload a cada 5 dias.

Ressalvas

As nossas mudanças no hot reload nem sempre significam que o compilador faz menos trabalho. Por exemplo, se você adicionar ou remover um método, o compilador não fará menos trabalho. Se você alterar o inicializador de um campo, o compilador não fará menos trabalho. Se você alterar a hierarquia de classes, o compilador não fará menos trabalho. Se você alterar o corpo de uma função — um caso em que o compilador geralmente deveria fazer menos trabalho — por causa de detalhes técnicos sobre mixins e FFI, o compilador ainda pode precisar fazer tanto trabalho quanto antes.

Além disso, deixamos de lado alguns detalhes técnicos ao falar sobre comparar arquivos. Primeiro, não podemos ignorar todos os comentários: precisamos manter a @dart marcação de versão porque ela tem significado semântico. Segundo, não podemos ignorar todos os corpos de função por causa de desafios específicos de implementação com mixins e FFI.

Conclusão

O hot reload já era rápido no Flutter 2.0, mas está mais rápido no Flutter 2.2. Em média, o hot reload é cerca de 30% mais rápido no Flutter 2.2 do que no Flutter 2.0, economizando, coletivamente, para as pessoas desenvolvedoras do Flutter, mais de um ano de espera pelo hot reload a cada 5 dias.

Se você ainda não atualizou (ou nem experimentou o Flutter), talvez seja um bom momento para visitar flutter.dev e experimentar.

Mais do Flutter