Node Types

The TypeScript compiler represents source code as an Abstract Syntax Tree (AST) composed of nodes. All nodes implement the base Node interface and are classified by their SyntaxKind.

Base Node Interface

All AST nodes extend the Node interface:

interface Node extends ReadonlyTextRange {
  readonly kind: SyntaxKind;
  readonly flags: NodeFlags;
  readonly parent: Node;
}

Key Properties

Property	Type	Description
`kind`	`SyntaxKind`	The syntax kind identifying the node type
`flags`	`NodeFlags`	Bitwise flags for node properties
`parent`	`Node`	Parent node in the AST
`pos`	`number`	Start position in source text
`end`	`number`	End position in source text

Core Node Types

Declaration Nodes

interface Declaration extends Node {
  _declarationBrand: any;
}

interface NamedDeclaration extends Declaration {
  readonly name?: DeclarationName;
}

Declaration nodes represent entities that introduce symbols into scope:

VariableDeclaration - Variable declarations
FunctionDeclaration - Function declarations
ClassDeclaration - Class declarations
InterfaceDeclaration - Interface declarations
TypeAliasDeclaration - Type alias declarations
EnumDeclaration - Enum declarations
ParameterDeclaration - Parameter declarations

Expression Nodes

Expressions are nodes that can be evaluated to produce a value:

type Expression = 
  | Identifier
  | BinaryExpression
  | CallExpression
  | PropertyAccessExpression
  | ArrayLiteralExpression
  | ObjectLiteralExpression
  // ... and many more

Common expression types:

Type	Description
`Identifier`	Variable or property name
`BinaryExpression`	Binary operations (e.g., `a + b`)
`CallExpression`	Function calls
`PropertyAccessExpression`	Property access (e.g., `obj.prop`)
`ElementAccessExpression`	Bracket notation (e.g., `arr[0]`)
`ArrowFunction`	Arrow function expressions
`FunctionExpression`	Function expressions

Statement Nodes

Statements are executable units of code:

type Statement =
  | VariableStatement
  | ExpressionStatement
  | IfStatement
  | ForStatement
  | WhileStatement
  | ReturnStatement
  | ThrowStatement
  // ... and more

Type Nodes

Type nodes represent TypeScript type annotations:

type TypeNode =
  | TypeReference
  | FunctionType
  | UnionType
  | IntersectionType
  | ArrayType
  | TupleType
  // ... and more

Container Nodes

Some nodes act as containers for other declarations:

interface LocalsContainer extends Node {
  _localsContainerBrand: any;
}

interface FlowContainer extends Node {
  _flowContainerBrand: any;
}

LocalsContainer

Nodes that can contain local symbols:

SourceFile
FunctionDeclaration
ModuleDeclaration
Block
ForStatement
CatchClause

FlowContainer

Nodes with control flow analysis:

Functions and methods
Statements (if, while, for, etc.)
Expressions with side effects

Common Node Patterns

Signature Declarations

interface SignatureDeclarationBase extends NamedDeclaration {
  readonly kind: SignatureDeclaration["kind"];
  readonly name?: PropertyName;
  readonly typeParameters?: NodeArray<TypeParameterDeclaration>;
  readonly parameters: NodeArray<ParameterDeclaration>;
  readonly type?: TypeNode;
}

Used by:

FunctionDeclaration
MethodDeclaration
ConstructorDeclaration
CallSignatureDeclaration
ConstructSignatureDeclaration

Variable Declarations

interface VariableDeclaration extends NamedDeclaration {
  readonly kind: SyntaxKind.VariableDeclaration;
  readonly name: BindingName;
  readonly exclamationToken?: ExclamationToken;
  readonly type?: TypeNode;
  readonly initializer?: Expression;
}

Parameter Declarations

interface ParameterDeclaration extends NamedDeclaration {
  readonly kind: SyntaxKind.Parameter;
  readonly modifiers?: NodeArray<ModifierLike>;
  readonly dotDotDotToken?: DotDotDotToken;
  readonly name: BindingName;
  readonly questionToken?: QuestionToken;
  readonly type?: TypeNode;
  readonly initializer?: Expression;
}

Working with Nodes

Type Guards

Use type guards to narrow node types:

import ts from 'typescript';

if (ts.isVariableDeclaration(node)) {
  // node is VariableDeclaration
  console.log(node.name.getText());
}

if (ts.isFunctionDeclaration(node)) {
  // node is FunctionDeclaration
  console.log(node.name?.getText());
}

Traversing the AST

function visit(node: ts.Node) {
  console.log(ts.SyntaxKind[node.kind]);
  ts.forEachChild(node, visit);
}

Node Relationships

Parent-Child

Every node (except the root) has a parent:

const parent = node.parent;
const children: ts.Node[] = [];
ts.forEachChild(node, child => children.push(child));

Source File

Get the source file for any node:

const sourceFile = node.getSourceFile();

Compiler API

Language Service API

Types and Interfaces

Base Node Interface

Key Properties

Core Node Types

Declaration Nodes

Expression Nodes

Statement Nodes

Type Nodes

Container Nodes

LocalsContainer

FlowContainer

Common Node Patterns

Signature Declarations

Variable Declarations

Parameter Declarations

Working with Nodes

Type Guards

Traversing the AST

Node Relationships

Parent-Child

Source File

See Also

Build docs developers (and LLMs) love

Compiler API

Language Service API

Types and Interfaces

​Base Node Interface

​Key Properties

​Core Node Types

​Declaration Nodes

​Expression Nodes

​Statement Nodes

​Type Nodes

​Container Nodes

​LocalsContainer

​FlowContainer

​Common Node Patterns

​Signature Declarations

​Variable Declarations

​Parameter Declarations

​Working with Nodes

​Type Guards

​Traversing the AST

​Node Relationships

​Parent-Child

​Source File

​See Also

Build docs developers (and LLMs) love

Base Node Interface

Key Properties

Core Node Types

Declaration Nodes

Expression Nodes

Statement Nodes

Type Nodes

Container Nodes

LocalsContainer

FlowContainer

Common Node Patterns

Signature Declarations

Variable Declarations

Parameter Declarations

Working with Nodes

Type Guards

Traversing the AST

Node Relationships

Parent-Child

Source File

See Also