Metaprogramming in Dart: AST Manipulation with Dill

Metaprogramming is a technique that treats programs as data, allowing a program to read, generate, analyze, transform, or even modify other programs (or itself) at compile‑time or runtime.

The article introduces the concept of metaprogramming, especially in the context of the Dart language. Dart’s intermediate representation, called Dill , can be manipulated through its AST (Abstract Syntax Tree) to implement features that are not directly supported by the language.

Metaprogramming is a programming technique in which computer programs have the ability to treat other programs as their data.

Typical uses of metaprogramming include code replacement via macros, generic programming, and runtime reflection. By operating on the AST during the compilation phases (FrontEnd → Optimizer → Backend) developers can inject new logic, generate functions, or modify existing ones without affecting runtime performance.

Dart compilation flow : source → kernel (Dill) → backend. Unlike Java or .NET IL, Dill is not meant to be written manually; instead it is produced and transformed programmatically via the AST library.

Example: creating a map variable and invoking its constructor through the AST.

Arguments mapFromArgs = Arguments.empty();
mapFromArgs.positional.add(MapLiteral([], keyType:keyInterType));
StaticInvocation mapConstructor = StaticInvocation(MapFromFactoryProc, mapFromArgs);
VariableDeclaration mapInstDecl = VariableDeclaration("jsonMap", type:mapInterType);
VariableSet set_mymap = VariableSet(mapInstDecl, mapConstructor);

Building a function body:

Block bodyStatements = Block<Statement>();
bodyStatements.addStatement(mapInstDecl);
bodyStatements.addStatement(ExpressionStatement(inst));

Creating a new procedure based on an existing one:

static Procedure createProcedure(Procedure referProcedure, Statement bodyStatements, DartType returnType) {
  FunctionNode functionNode = new FunctionNode(bodyStatements);
  // ... parameters omitted
  Procedure procedure = new Procedure(Name(referProcedure.canonicalName.name, referProcedure.name.library), ProcedureKind.Method, functionNode);
  return procedure;
}

Debugging Dill files can be done by converting them to a readable text format:

$DartHome/dart ../../pkg/vm/bin/dump_kernel.dart /your/dill/file/path /output/dill/text/file.text

Application ideas include injecting AOP logic by traversing the AST (e.g., the open‑source AspectD library) and simplifying JSON serialization. A lightweight LiteMirror library could be built on top of Dart metaprogramming to provide reflection‑like capabilities without using the discouraged Mirror API.

Overall, Dart’s metaprogramming via Dill and AST manipulation offers powerful compile‑time code generation, custom serialization, and potential AOP/hook extensions.