Skip to main content
The Kernel AST is an in-memory representation of Dart programs designed for transformation and analysis. This page documents the main AST node types and their structure.

​
Base Types

All AST nodes inherit from TreeNode, the base class for all nodes in the tree: 
abstract class TreeNode {
  TreeNode? parent;
  int fileOffset = noOffset;
  
  R accept<R>(Visitor<R> v);
  void visitChildren(Visitor v);
  void transformChildren(Transformer v);
}

​
Component and Libraries

​
Component

The root of a Kernel program: 
class Component extends TreeNode {
  final CanonicalName root;
  final List<Library> libraries;
  final Map<Uri, Source> uriToSource;
  final Map<String, MetadataRepository<dynamic>> metadata;
  Reference? mainMethodName;
}

​
Library

Represents a Dart library: 
class Library extends NamedNode {
  String name;
  Uri importUri;
  Uri fileUri;
  List<Expression> annotations;
  List<LibraryDependency> libraryDependencies;
  List<Typedef> typedefs;
  List<Class> classes;
  List<Extension> extensions;
  List<ExtensionTypeDeclaration> extensionTypeDeclarations;
  List<Field> fields;
  List<Procedure> procedures;
}

​
Type Declarations

​
Class

Regular class or mixin application: 
class class extends NamedNode implements TypeDeclaration {
  String name;
  List<Expression> annotations;
  List<TypeParameter> typeParameters;
  DartType? supertype;
  DartType? mixedInType;
  List<DartType> implementedTypes;
  List<Field> fields;
  List<Constructor> constructors;
  List<Procedure> procedures;
  
  // Flags
  bool isAbstract;
  bool isEnum;
  bool isMixinDeclaration;
  bool isSealed;
  bool isFinal;
  bool isBase;
  bool isInterface;
  bool isMixinClass;
}

​
Extension

Extension declarations: 
class Extension extends NamedNode {
  String name;
  List<TypeParameter> typeParameters;
  DartType onType;
  List<ExtensionMemberDescriptor> members;
}

​
ExtensionTypeDeclaration

Extension type declarations (Dart 3.0+): 
class ExtensionTypeDeclaration extends NamedNode {
  String name;
  List<TypeParameter> typeParameters;
  DartType declaredRepresentationType;
  String representationName;
  List<DartType> implements;
  List<Procedure> procedures;
  List<ExtensionTypeMemberDescriptor> members;
}

​
Members

​
Field

class Field extends Member {
  Name name;
  DartType type;
  Expression? initializer;
  
  bool isFinal;
  bool isConst;
  bool isStatic;
  bool isLate;
  bool isCovariantByDeclaration;
}

​
Constructor

class Constructor extends Member {
  Name name;
  FunctionNode function;
  List<Initializer> initializers;
  
  bool isConst;
  bool isExternal;
  bool isSynthetic;
}

​
Procedure

Methods, getters, setters, operators, and factory constructors: 
class Procedure extends Member {
  Name name;
  ProcedureKind kind; // Method, Getter, Setter, Operator, Factory
  FunctionNode function;
  
  bool isStatic;
  bool isAbstract;
  bool isExternal;
  bool isConst;
}

​
FunctionNode

Represents function signatures and bodies: 
class FunctionNode extends TreeNode {
  List<TypeParameter> typeParameters;
  List<VariableDeclaration> positionalParameters;
  List<VariableDeclaration> namedParameters;
  int requiredParameterCount;
  DartType returnType;
  Statement? body;
  AsyncMarker asyncMarker; // Sync, Async, SyncStar, AsyncStar
}

​
Expressions

Expressions represent computations that produce values.

​
Literals

// Basic literals
class IntLiteral extends Expression {
  int value;
}

class DoubleLiteral extends Expression {
  double value;
}

class BoolLiteral extends Expression {
  bool value;
}

class StringLiteral extends Expression {
  String value;
}

class NullLiteral extends Expression {}

class SymbolLiteral extends Expression {
  String value;
}

class TypeLiteral extends Expression {
  DartType type;
}

​
Collection Literals

class ListLiteral extends Expression {
  DartType typeArgument;
  List<Expression> expressions;
}

class SetLiteral extends Expression {
  DartType typeArgument;
  List<Expression> expressions;
}

class MapLiteral extends Expression {
  DartType keyType;
  DartType valueType;
  List<MapLiteralEntry> entries;
}

class RecordLiteral extends Expression {
  List<Expression> positional;
  List<NamedExpression> named;
  DartType recordType;
}

​
Variable Access

class VariableGet extends Expression {
  VariableDeclaration variable;
  DartType? promotedType;
}

class VariableSet extends Expression {
  VariableDeclaration variable;
  Expression value;
}

​
Property Access

class InstanceGet extends Expression {
  Expression receiver;
  Name name;
  DartType resultType;
  Member? interfaceTarget;
}

class InstanceSet extends Expression {
  Expression receiver;
  Name name;
  Expression value;
  Member? interfaceTarget;
}

class DynamicGet extends Expression {
  Expression receiver;
  Name name;
}

class StaticGet extends Expression {
  Member target;
}

class SuperPropertyGet extends Expression {
  Name name;
  Member? interfaceTarget;
}

​
Invocations

class InstanceInvocation extends Expression {
  Expression receiver;
  Name name;
  Arguments arguments;
  DartType functionType;
  Member? interfaceTarget;
}

class DynamicInvocation extends Expression {
  Expression receiver;
  Name name;
  Arguments arguments;
}

class FunctionInvocation extends Expression {
  Expression receiver;
  Arguments arguments;
  DartType functionType;
}

class StaticInvocation extends Expression {
  Procedure target;
  Arguments arguments;
}

class ConstructorInvocation extends Expression {
  Constructor target;
  Arguments arguments;
}

​
Control Flow Expressions

class ConditionalExpression extends Expression {
  Expression condition;
  Expression then;
  Expression otherwise;
  DartType? staticType;
}

class LogicalExpression extends Expression {
  Expression left;
  LogicalOperator operator; // &&, ||
  Expression right;
}

class Let extends Expression {
  VariableDeclaration variable;
  Expression body;
}

​
Type Operations

class IsExpression extends Expression {
  Expression operand;
  DartType type;
}

class AsExpression extends Expression {
  Expression operand;
  DartType type;
  bool isTypeError;
  bool isCovarianceCheck;
}

class NullCheck extends Expression {
  Expression operand;
}

​
Pattern Matching (Dart 3.0+)

class SwitchExpression extends Expression {
  Expression expression;
  List<SwitchExpressionCase> cases;
  DartType? staticType;
}

class PatternAssignment extends Expression {
  Pattern pattern;
  Expression expression;
}

​
Statements

​
Basic Statements

class ExpressionStatement extends Statement {
  Expression expression;
}

class Block extends Statement {
  List<Statement> statements;
}

class EmptyStatement extends Statement {}

class ReturnStatement extends Statement {
  Expression? expression;
}

​
Variable Declaration

class VariableDeclaration extends Statement {
  String name;
  DartType type;
  Expression? initializer;
  
  bool isFinal;
  bool isConst;
  bool isLate;
  bool isRequired;
}

​
Control Flow

class IfStatement extends Statement {
  Expression condition;
  Statement then;
  Statement otherwise;
}

class WhileStatement extends Statement {
  Expression condition;
  Statement body;
}

class DoStatement extends Statement {
  Statement body;
  Expression condition;
}

class ForStatement extends Statement {
  List<VariableDeclaration> variables;
  Expression? condition;
  List<Expression> updates;
  Statement body;
}

class ForInStatement extends Statement {
  VariableDeclaration variable;
  Expression iterable;
  Statement body;
}

​
Switch Statement

class SwitchStatement extends Statement {
  Expression expression;
  List<SwitchCase> cases;
  bool isExplicitlyExhaustive;
}

class SwitchCase {
  List<Expression> expressions;
  Statement body;
  bool isDefault;
}

class PatternSwitchStatement extends Statement {
  Expression expression;
  List<PatternSwitchCase> cases;
}

​
Exception Handling

class TryCatch extends Statement {
  Statement body;
  List<Catch> catches;
}

class Catch {
  DartType guard;
  VariableDeclaration? exception;
  VariableDeclaration? stackTrace;
  Statement body;
}

class TryFinally extends Statement {
  Statement body;
  Statement finalizer;
}

class Throw extends Expression {
  Expression expression;
}

​
Labels and Jumps

class LabeledStatement extends Statement {
  Statement body;
}

class BreakStatement extends Statement {
  LabeledStatement target;
}

class ContinueSwitchStatement extends Statement {
  SwitchCase target;
}

​
Async

class YieldStatement extends Statement {
  Expression expression;
  bool isYieldStar;
}

class AwaitExpression extends Expression {
  Expression operand;
}

​
DartType Hierarchy

Kernel uses a type system separate from the Dart type system: 
abstract class DartType extends Node {}

class DynamicType extends DartType {}
class VoidType extends DartType {}
class NeverType extends DartType {
  Nullability nullability;
}
class NullType extends DartType {}
class InvalidType extends DartType {}

class InterfaceType extends DartType {
  Class classNode;
  List<DartType> typeArguments;
  Nullability nullability;
}

class FunctionType extends DartType {
  List<TypeParameter> typeParameters;
  List<DartType> positionalParameters;
  List<NamedType> namedParameters;
  DartType returnType;
  Nullability nullability;
}

class TypeParameterType extends DartType {
  TypeParameter parameter;
  Nullability nullability;
}

class RecordType extends DartType {
  List<DartType> positional;
  List<NamedType> named;
  Nullability nullability;
}

class ExtensionType extends DartType {
  ExtensionTypeDeclaration extensionTypeDeclaration;
  List<DartType> typeArguments;
  DartType typeErasure;
  Nullability nullability;
}

​
Nullability

enum Nullability {
  nullable,      // T?
  nonNullable,   // T (in null-safe code)
  neither,       // T (in legacy code)
}

​
Visitors

Kernel provides visitor infrastructure for traversing the AST: 
abstract class Visitor<R> {
  R visitComponent(Component node);
  R visitLibrary(Library node);
  R visitClass(Class node);
  R visitField(Field node);
  R visitProcedure(Procedure node);
  // ... methods for all node types
}

abstract class RecursiveVisitor extends Visitor<void> {
  // Default implementation visits all children
}

abstract class Transformer extends TreeVisitor<TreeNode> {
  // Enables AST transformations
}

​
Constants

Compile-time constants have their own representation: 
abstract class Constant extends Node {}

class NullConstant extends Constant {}
class BoolConstant extends Constant { bool value; }
class IntConstant extends Constant { int value; }
class DoubleConstant extends Constant { double value; }
class StringConstant extends Constant { String value; }

class ListConstant extends Constant {
  DartType typeArgument;
  List<Constant> entries;
}

class MapConstant extends Constant {
  DartType keyType;
  DartType valueType;
  List<ConstantMapEntry> entries;
}

class InstanceConstant extends Constant {
  Class classNode;
  List<DartType> typeArguments;
  Map<Field, Constant> fieldValues;
}

​
Usage Examples

​
Traversing the AST

class PrintingVisitor extends RecursiveVisitor {
  int depth = 0;
  
  @override
  void visitClass(Class node) {
    print('${'  ' * depth}class ${node.name}');
    depth++;
    super.visitClass(node);
    depth--;
  }
  
  @override
  void visitProcedure(Procedure node) {
    print('${'  ' * depth}${node.kind.name} ${node.name}');
  }
}

​
Transforming the AST

class RemoveAsserts extends Transformer {
  @override
  TreeNode visitAssertStatement(AssertStatement node) {
    return EmptyStatement();
  }
}

Build docs developers (and LLMs) love

Get started for freeTalk to us