Att fixa "Den del av direktivet måste vara det enda direktivet i en del" är ett sätt att fixa Dart Macro-fel.

Att övervinna deldirektivets konflikter i Dart-makron

Att arbeta med experimentella funktioner i Dart kan vara en spännande men ändå utmanande resa för utvecklare som söker avancerade funktioner. Nyligen dykade jag in i Dart-makron för att anpassa klassbeteende och automatisera repetitiva uppgifter i mitt Flutter-projekt. Men som med många experimentella verktyg, stötte jag på ett fel som gjorde mig chockad och efter att ha sökt efter svar insåg jag att andra kan ha samma problem. 🛠️

Problemet uppstår när man använder makron i Flutters betakanal—särskilt vid importer i en utökad fil, där felet "del av direktivet måste vara det enda direktivet" uppstår. Denna direktivbegränsning lägger till komplexitet, eftersom makron i Dart för närvarande kräver specifika IDE-inställningar, som vanligtvis fungerar bäst i VSCode. Ändå gör kraften de erbjuder dem värda ansträngningen att förstå.

I det här fallet fungerade mitt anpassade makro som förväntat och genererade de önskade klassförstärkningarna. Den automatiskt genererade koden inkluderade dock ytterligare importer, vilket, som det visar sig, strider mot Darts regel för delfiler. I huvudsak bör varje delfil som är länkad till ett bibliotek endast innehålla ett enda "del-av"-direktiv utan ytterligare importer.

Om du har stött på det här problemet eller bara vill utforska Dart-makron mer djupgående, följ med när jag beskriver orsaken till felet och stegen för att lösa det. Att förstå detta kommer att hjälpa alla som använder makron i Flutter att uppnå smidigare utvecklingsarbetsflöden utan onödiga vägspärrar. 🚀

Använda Dart-makron för att lösa direktivkonflikter i Flutter

När man arbetar med Dart-makron i Flutters betakanal kan det vara svårt att hantera delfiler på rätt sätt, speciellt när det gäller att uppfylla begränsningarna för "del av direktivet". För att dyka in i detta fokuserar de tillhandahållna skripten på att hantera importer och förstärkningar på ett sätt som ligger i linje med Darts regler, vilket säkerställer att utökade filer inte bryter mot kravet "del av direktivet". Detta innebär att du tar bort eventuella ytterligare importer från filer markerade som "del av" en annan. Genom att centralisera importer i huvudbiblioteksfilen och hantera klassförstärkningar inom makron kan vi upprätthålla struktur utan ytterligare importer i de utökade filerna, vilket förhindrar att felet utlöses. 🛠️

Klassen anpassad makro, `ReviewableModule`, definierar både deklarationer och definitioner för klassen den utökar. Detta makro använder metoder som `declareInType` och `augment`, som är speciellt anpassade för att infoga nya deklarationer eller lägga till funktionalitet till befintliga metoder i utökade klasser. Med `declareInType` deklarerar vi medlemmar, som getters eller setters, utan att manuellt lägga till dem i den ursprungliga koden. Makrot "bygger" i princip nya delar av klassen vid kompilering. Detta tillvägagångssätt hjälper till att dynamiskt definiera klassstrukturer och automatisera uppgifter, minska mängden repetitiv kodning och möjliggöra en renare, centraliserad kodbas.

Genom att använda `FunctionBodyCode.fromParts` undviker vi att hårdkoda funktionskroppen helt och hållet och bygger den istället bit för bit. Detta håller makrot modulärt och gör det enkelt att lägga till anpassade uttalanden eller annan komplex logik dynamiskt. Samtidigt hjälper `buildMethod` i vår makroklass att referera till befintliga metoder, vilket gör att vi kan modifiera dem istället för att skriva om eller duplicera funktionalitet. I det här exemplet används den för att justera "binds" getter. På så sätt blir makrot effektivt en kodgenerator som utökar och modifierar kod dynamiskt, vilket ger en hög nivå av anpassning. Förstärkningen av "binds" för att inkludera "...augmented" förenklar vår uppgift, eftersom den automatiserar inkludering utan att manuellt expandera varje möjligt element.

För att testa dessa förstärkningar effektivt sätts en enhetstest-fil upp med en grupp tester som är specifika för den utökade klassen "HomeModule". Gruppfunktionen hjälper till att hålla ordning på testerna, vilket gör det lättare att felsöka eller utöka testfall. Genom att verifiera att vår "binds" getter returnerar den förväntade typen och strukturen, säkerställer vi att makroförstärkningen inte bara fungerar syntaktisk utan också fungerar som avsett i verkliga scenarier. Dessa tester blir särskilt värdefulla i betamiljön, där de experimentella funktionerna kan introducera oförutsedda egenheter eller problem.

Sammantaget ger denna makrobaserade lösning ett flexibelt sätt att hantera komplexa klassförstärkningar samtidigt som man följer Darts delfilsbegränsningar. För alla som sysslar med makron i Flutter eller experimenterar med automatisering vid kompileringstid, kan detta tillvägagångssätt förenkla utvecklingen och göra kod lättare att hantera och skala. Även om felet kan verka som ett litet problem, sparar man tid och förhindrar att liknande problem stör framtida utvecklingsarbetsflöden genom att förstå orsaken och implementera en modulär, makrobaserad lösning. 🚀

import 'dart:async';
import 'package:flutter/material.dart';
import 'package:macros/macros.dart';
// Define a macro class that implements ClassDeclarationsMacro and ClassDefinitionMacro
macro class ReviewableModule implements ClassDeclarationsMacro, ClassDefinitionMacro {
  const ReviewableModule();
  @override
  FutureOr<void> buildDeclarationsForClass(ClassDeclaration clazz, MemberDeclarationBuilder builder) async {
    builder.declareInType(DeclarationCode.fromParts(['external List<Bind> get binds;']));
  }
  @override
  FutureOr<void> buildDefinitionForClass(ClassDeclaration clazz, TypeDefinitionBuilder builder) async {
    var bindsGetter = (await builder.methodsOf(clazz)).firstWhere((method) => method.identifier.name == 'binds');
    var bindsMethod = await builder.buildMethod(bindsGetter.identifier);
    bindsMethod.augment(FunctionBodyCode.fromParts(['{\n', 'return [\n', '...augmented,\n', '];\n', '}']));
  }
}

// Original library file
library macros_test;
// List all imports here instead of in part files
import 'dart:core';
import 'package:flutter_modular/src/presenter/models/bind.dart';
part 'home_module.g.dart';
// Macro code in home_module.dart
part of 'package:macros_test/home_module.dart';
augment class HomeModule {
  augment List<Bind> get binds => [...augmented];
}

// Unit test file: test/home_module_test.dart
import 'package:flutter_test/flutter_test.dart';
import 'package:macros_test/home_module.dart';
void main() {
  group('HomeModule Macro Tests', () {
    test('Check binds augmentation', () {
      final module = HomeModule();
      expect(module.binds, isNotNull);
      expect(module.binds, isA<List<Bind>>());
    });
  });
}

Förbättra kodeffektiviteten med Dart-makron i Flutter

En spännande aspekt av Dart-makron är deras förmåga att utöka klasser och metoder dynamiskt vid kompilering, vilket avsevärt kan minska repetitiv kodning. När du använder Flutter, särskilt med betakanalen, tillåter makron utvecklare att effektivisera kod på sätt som inte skulle vara möjligt med traditionella metoder. Till exempel, i samband med att hantera beroenden eller konfigurera tjänsteleverantörer, kan makron automatiskt lägga till nödvändiga getters eller metoder utan att kräva manuell inmatning. Detta kan spara mycket tid för utvecklare, särskilt när de arbetar med komplexa appar som har flera beroenden eller modulariserade komponenter. ⚙️

Utmaningen ligger dock i att se till att utökade filer följer Darts strikta "del av direktiv"-regeln, som begränsar ytterligare importsatser i filer som använder detta direktiv. Normalt skulle utvecklare inkludera importer direkt i filen där de behövs, men i det här fallet är det nödvändigt att centralisera dem i en primär biblioteksfil. Denna begränsning kan verka restriktiv men tvingar utvecklare att strukturera sin kod mer effektivt och skapa tydliga gränser mellan olika delar av biblioteket. Detta innebär också att makron används för att direkt infoga alla nödvändiga funktioner i de utökade delarna, snarare än att hämta från extern import.

En annan väsentlig fördel med makron är deras förmåga att producera kod som är både mer läsbar och modulär. Genom att utnyttja kommandon som declareInType och buildMethod, den genererade koden är ren och fokuserar endast på den nödvändiga logiken för varje del. Detta håller inte bara de utökade delarna kompatibla med Darts strikta riktlinjer utan möjliggör också en ren, underhållsbar kodbas på lång sikt. Även om Dart-makron fortfarande är i ett tidigt skede kan utvecklarna förberedas för ett mer effektivt och optimerat tillvägagångssätt för kodning i Flutter att lära sig att arbeta med dessa begränsningar effektivt. 🚀