Skip to content
Permalink
master
Switch branches/tags
Go to file
 
 
Cannot retrieve contributors at this time
1363 lines (1042 sloc) 27.2 KB

These are the core @babel/parser (babylon) AST node types.

Node objects

AST nodes are represented as Node objects, which may have any prototype inheritance but which implement the following interface:

interface Node {
  type: string;
  loc: SourceLocation | null;
}

The type field is a string representing the AST variant type. Each subtype of Node is documented below with the specific string of its type field. You can use this field to determine which interface a node implements.

The loc field represents the source location information of the node. If the node contains no information about the source location, the field is null; otherwise it is an object consisting of a start position (the position of the first character of the parsed source region) and an end position (the position of the first character after the parsed source region):

interface SourceLocation {
  source: string | null;
  start: Position;
  end: Position;
}

Each Position object consists of a line number (1-indexed) and a column number (0-indexed):

interface Position {
  line: number; // >= 1
  column: number; // >= 0
}

Changes

@babel/parser (Babylon) v7

Flow: Node renamed from ExistentialTypeParam to ExistsTypeAnnotation #322

Flow: Node renamed from NumericLiteralTypeAnnotation to NumberLiteralTypeAnnotation babel/babylon#332

Flow: Node Variance which replaces the string value of the variance field on several nodes babel/babylon#333

Flow: ObjectTypeIndexer location info matches Flow's better babel/babylon#228

Node ForAwaitStatement has been removed #349 in favor of modifying ForOfStatement

RestProperty and SpreadProperty have been dropped in favor of RestElement and SpreadElement.

Identifier

interface Identifier <: Expression, Pattern {
  type: "Identifier";
  name: string;
}

An identifier. Note that an identifier may be an expression or a destructuring pattern.

PrivateName

interface PrivateName <: Expression, Pattern {
  type: "PrivateName";
  id: Identifier;
}

A Private Name Identifier.

Literals

interface Literal <: Expression { }

A literal token. May or may not represent an expression.

RegExpLiteral

interface RegExpLiteral <: Literal {
  type: "RegExpLiteral";
  pattern: string;
  flags: string;
}

NullLiteral

interface NullLiteral <: Literal {
  type: "NullLiteral";
}

StringLiteral

interface StringLiteral <: Literal {
  type: "StringLiteral";
  value: string;
}

BooleanLiteral

interface BooleanLiteral <: Literal {
  type: "BooleanLiteral";
  value: boolean;
}

NumericLiteral

interface NumericLiteral <: Literal {
  type: "NumericLiteral";
  value: number;
}

BigIntLiteral

interface BigIntLiteral <: Literal {
  type: "BigIntLiteral";
  value: string;
}

The value property is the string representation of the BigInt value. It doesn't include the suffix n.

Programs

interface Program <: Node {
  type: "Program";
  interpreter: InterpreterDirective | null;
  sourceType: "script" | "module";
  body: [ Statement | ModuleDeclaration ];
  directives: [ Directive ];
}

A complete program source tree.

Parsers must specify sourceType as "module" if the source has been parsed as an ES6 module. Otherwise, sourceType must be "script".

Functions

interface Function <: Node {
  id: Identifier | null;
  params: [ Pattern ];
  body: BlockStatement;
  generator: boolean;
  async: boolean;
}

A function declaration or expression.

Statements

interface Statement <: Node { }

Any statement.

ExpressionStatement

interface ExpressionStatement <: Statement {
  type: "ExpressionStatement";
  expression: Expression;
}

An expression statement, i.e., a statement consisting of a single expression.

BlockStatement

interface BlockStatement <: Statement {
  type: "BlockStatement";
  body: [ Statement ];
  directives: [ Directive ];
}

A block statement, i.e., a sequence of statements surrounded by braces.

EmptyStatement

interface EmptyStatement <: Statement {
  type: "EmptyStatement";
}

An empty statement, i.e., a solitary semicolon.

DebuggerStatement

interface DebuggerStatement <: Statement {
  type: "DebuggerStatement";
}

A debugger statement.

WithStatement

interface WithStatement <: Statement {
  type: "WithStatement";
  object: Expression;
  body: Statement;
}

A with statement.

Control flow

ReturnStatement

interface ReturnStatement <: Statement {
  type: "ReturnStatement";
  argument: Expression | null;
}

A return statement.

LabeledStatement

interface LabeledStatement <: Statement {
  type: "LabeledStatement";
  label: Identifier;
  body: Statement;
}

A labeled statement, i.e., a statement prefixed by a break/continue label.

BreakStatement

interface BreakStatement <: Statement {
  type: "BreakStatement";
  label: Identifier | null;
}

A break statement.

ContinueStatement

interface ContinueStatement <: Statement {
  type: "ContinueStatement";
  label: Identifier | null;
}

A continue statement.

Choice

IfStatement

interface IfStatement <: Statement {
  type: "IfStatement";
  test: Expression;
  consequent: Statement;
  alternate: Statement | null;
}

An if statement.

SwitchStatement

interface SwitchStatement <: Statement {
  type: "SwitchStatement";
  discriminant: Expression;
  cases: [ SwitchCase ];
}

A switch statement.

SwitchCase

interface SwitchCase <: Node {
  type: "SwitchCase";
  test: Expression | null;
  consequent: [ Statement ];
}

A case (if test is an Expression) or default (if test === null) clause in the body of a switch statement.

Exceptions

ThrowStatement

interface ThrowStatement <: Statement {
  type: "ThrowStatement";
  argument: Expression;
}

A throw statement.

TryStatement

interface TryStatement <: Statement {
  type: "TryStatement";
  block: BlockStatement;
  handler: CatchClause | null;
  finalizer: BlockStatement | null;
}

A try statement. If handler is null then finalizer must be a BlockStatement.

CatchClause

interface CatchClause <: Node {
  type: "CatchClause";
  param?: Pattern;
  body: BlockStatement;
}

A catch clause following a try block.

Loops

WhileStatement

interface WhileStatement <: Statement {
  type: "WhileStatement";
  test: Expression;
  body: Statement;
}

A while statement.

DoWhileStatement

interface DoWhileStatement <: Statement {
  type: "DoWhileStatement";
  body: Statement;
  test: Expression;
}

A do/while statement.

ForStatement

interface ForStatement <: Statement {
  type: "ForStatement";
  init: VariableDeclaration | Expression | null;
  test: Expression | null;
  update: Expression | null;
  body: Statement;
}

A for statement.

ForInStatement

interface ForInStatement <: Statement {
  type: "ForInStatement";
  left: VariableDeclaration |  Expression;
  right: Expression;
  body: Statement;
}

A for/in statement.

ForOfStatement

interface ForOfStatement <: ForInStatement {
  type: "ForOfStatement";
  await: boolean;
}

Declarations

interface Declaration <: Statement { }

Any declaration node. Note that declarations are considered statements; this is because declarations can appear in any statement context.

FunctionDeclaration

interface FunctionDeclaration <: Function, Declaration {
  type: "FunctionDeclaration";
  id: Identifier;
}

A function declaration. Note that unlike in the parent interface Function, the id cannot be null, except when this is the child of an ExportDefaultDeclaration.

VariableDeclaration

interface VariableDeclaration <: Declaration {
  type: "VariableDeclaration";
  declarations: [ VariableDeclarator ];
  kind: "var" | "let" | "const";
}

A variable declaration.

VariableDeclarator

interface VariableDeclarator <: Node {
  type: "VariableDeclarator";
  id: Pattern;
  init: Expression | null;
}

A variable declarator.

Misc

Decorator

interface Decorator <: Node {
  type: "Decorator";
  expression: Expression;
}

Directive

interface Directive <: Node {
  type: "Directive";
  value: DirectiveLiteral;
}

DirectiveLiteral

interface DirectiveLiteral <: StringLiteral {
  type: "DirectiveLiteral";
}

InterpreterDirective

interface InterpreterDirective <: StringLiteral {
  type: "InterpreterDirective";
}

Expressions

interface Expression <: Node { }

Any expression node. Since the left-hand side of an assignment may be any expression in general, an expression can also be a pattern.

Super

interface Super <: Node {
    type: "Super";
}

A super pseudo-expression.

Import

interface Import <: Node {
    type: "Import";
}

A import pseudo-expression.

ThisExpression

interface ThisExpression <: Expression {
  type: "ThisExpression";
}

A this expression.

ArrowFunctionExpression

interface ArrowFunctionExpression <: Function, Expression {
  type: "ArrowFunctionExpression";
  body: BlockStatement | Expression;
}

A fat arrow function expression, e.g., let foo = (bar) => { /* body */ }.

YieldExpression

interface YieldExpression <: Expression {
  type: "YieldExpression";
  argument: Expression | null;
  delegate: boolean;
}

A yield expression.

AwaitExpression

interface AwaitExpression <: Expression {
  type: "AwaitExpression";
  argument: Expression | null;
}

A await expression.

ArrayExpression

interface ArrayExpression <: Expression {
  type: "ArrayExpression";
  elements: [ Expression | SpreadElement | null ];
}

An array expression.

ObjectExpression

interface ObjectExpression <: Expression {
  type: "ObjectExpression";
  properties: [ ObjectProperty | ObjectMethod | SpreadElement ];
}

An object expression.

ObjectMember

interface ObjectMember <: Node {
  key: Expression;
  computed: boolean;
  decorators: [ Decorator ];
}

ObjectProperty

interface ObjectProperty <: ObjectMember {
  type: "ObjectProperty";
  shorthand: boolean;
  value: Expression;
}

ObjectMethod

interface ObjectMethod <: ObjectMember, Function {
  type: "ObjectMethod";
  kind: "get" | "set" | "method";
}

RecordExpression

interface RecordExpression <: Expression {
  type: "RecordExpression";
  properties: [ ObjectProperty | ObjectMethod | SpreadElement ];
}

TupleExpression

interface TupleExpression <: Expression {
  type: "TupleExpression";
  elements: [ Expression | SpreadElement | null ];
}

FunctionExpression

interface FunctionExpression <: Function, Expression {
  type: "FunctionExpression";
}

A function expression.

Unary operations

UnaryExpression

interface UnaryExpression <: Expression {
  type: "UnaryExpression";
  operator: UnaryOperator;
  prefix: boolean;
  argument: Expression;
}

A unary operator expression.

UnaryOperator

enum UnaryOperator {
  "-" | "+" | "!" | "~" | "typeof" | "void" | "delete" | "throw"
}

A unary operator token.

UpdateExpression

interface UpdateExpression <: Expression {
  type: "UpdateExpression";
  operator: UpdateOperator;
  argument: Expression;
  prefix: boolean;
}

An update (increment or decrement) operator expression.

UpdateOperator

enum UpdateOperator {
  "++" | "--"
}

An update (increment or decrement) operator token.

Binary operations

BinaryExpression

interface BinaryExpression <: Expression {
  type: "BinaryExpression";
  operator: BinaryOperator;
  left: Expression;
  right: Expression;
}

A binary operator expression.

BinaryOperator

enum BinaryOperator {
  "==" | "!=" | "===" | "!=="
     | "<" | "<=" | ">" | ">="
     | "<<" | ">>" | ">>>"
     | "+" | "-" | "*" | "/" | "%"
     | "**" | "|" | "^" | "&" | "in"
     | "instanceof"
     | "|>"
}

A binary operator token.

AssignmentExpression

interface AssignmentExpression <: Expression {
  type: "AssignmentExpression";
  operator: AssignmentOperator;
  left: Pattern | Expression;
  right: Expression;
}

An assignment operator expression. It has short-circuiting behaviour if the operator is one of "||=", "&&=", and "??=".

AssignmentOperator

enum AssignmentOperator {
  "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "**="
    | "<<=" | ">>=" | ">>>="
    | "|=" | "^=" | "&="
    | "||=" | "&&=" | "??="
}

An assignment operator token.

LogicalExpression

interface LogicalExpression <: Expression {
  type: "LogicalExpression";
  operator: LogicalOperator;
  left: Expression;
  right: Expression;
}

A logical operator expression.

LogicalOperator

enum LogicalOperator {
  "||" | "&&" | "??"
}

A logical operator token.

SpreadElement

interface SpreadElement <: Node {
  type: "SpreadElement";
  argument: Expression;
}

ArgumentPlaceholder

interface ArgumentPlaceholder <: Node {
    type: "ArgumentPlaceholder";
}

MemberExpression

interface MemberExpression <: Expression, Pattern {
  type: "MemberExpression";
  object: Expression | Super;
  property: Expression;
  computed: boolean;
}

A member expression. If computed is true, the node corresponds to a computed (a[b]) member expression and property is an Expression. If computed is false, the node corresponds to a static (a.b) member expression and property is an Identifier or a PrivateName.

BindExpression

interface BindExpression <: Expression {
    type: "BindExpression";
    object: Expression | null;
    callee: Expression;
}

If object is null, then callee should be a MemberExpression.

Pipeline

These nodes are used by the Smart Pipeline to determine the type of the expression in a Pipeline Operator Expression. The F# Pipeline uses simple BinaryExpressions.

PipelineBody

interface PipelineBody <: NodeBase {
    type: "PipelineBody";
}

PipelineBareFunctionBody

interface PipelineBody <: NodeBase {
    type: "PipelineBareFunctionBody";
    callee: Expression;
}

PipelineBareConstructorBody

interface PipelineBareConstructorBody <: NodeBase {
    type: "PipelineBareConstructorBody";
    callee: Expression;
}

PipelineBareAwaitedFunctionBody

interface PipelineBareConstructorBody <: NodeBase {
    type: "PipelineTopicBody";
    expression: Expression;
}

PipelineTopicBody

interface PipelineBareConstructorBody <: NodeBase {
    type: "PipelineBareAwaitedFunctionBody";
    callee: Expression;
}

ConditionalExpression

interface ConditionalExpression <: Expression {
  type: "ConditionalExpression";
  test: Expression;
  alternate: Expression;
  consequent: Expression;
}

A conditional expression, i.e., a ternary ?/: expression.

CallExpression

interface CallExpression <: Expression {
  type: "CallExpression";
  callee: Expression | Super | Import;
  arguments: [ Expression | SpreadElement ];
}

A function or method call expression. When the callee is Import, the arguments must have only one Expression element.

NewExpression

interface NewExpression <: CallExpression {
  type: "NewExpression";
}

A new expression.

SequenceExpression

interface SequenceExpression <: Expression {
  type: "SequenceExpression";
  expressions: [ Expression ];
}

A sequence expression, i.e., a comma-separated sequence of expressions.

ParenthesizedExpression

interface ParenthesizedExpression <: Expression {
    type "ParenthesizedExpression";
    expression: Expression;
}

An expression wrapped by parentheses. By default @babel/parser does not create this node, unless the createParenthesizedExpressions: true option is passed.

DoExpression

interface DoExpression <: Expression {
  type: "DoExpression";
  body: BlockStatement
}

Template Literals

TemplateLiteral

interface TemplateLiteral <: Expression {
  type: "TemplateLiteral";
  quasis: [ TemplateElement ];
  expressions: [ Expression ];
}

TaggedTemplateExpression

interface TaggedTemplateExpression <: Expression {
  type: "TaggedTemplateExpression";
  tag: Expression;
  quasi: TemplateLiteral;
}

TemplateElement

interface TemplateElement <: Node {
  type: "TemplateElement";
  tail: boolean;
  value: {
    cooked: string | null;
    raw: string;
  };
}

Patterns

interface Pattern <: Node { }

ObjectPattern

interface AssignmentProperty <: ObjectProperty {
  value: Pattern;
}

interface ObjectPattern <: Pattern {
  type: "ObjectPattern";
  properties: [ AssignmentProperty | RestElement ];
}

ArrayPattern

interface ArrayPattern <: Pattern {
  type: "ArrayPattern";
  elements: [ Pattern | null ];
}

RestElement

interface RestElement <: Pattern {
  type: "RestElement";
  argument: Pattern;
}

AssignmentPattern

interface AssignmentPattern <: Pattern {
  type: "AssignmentPattern";
  left: Pattern;
  right: Expression;
}

Classes

interface Class <: Node {
  id: Identifier | null;
  superClass: Expression | null;
  body: ClassBody;
  decorators: [ Decorator ];
}

ClassBody

interface ClassBody <: Node {
  type: "ClassBody";
  body: [ ClassMethod | ClassPrivateMethod | ClassProperty | ClassPrivateProperty ];
}

ClassMethod

interface ClassMethod <: Function {
  type: "ClassMethod";
  key: Expression;
  kind: "constructor" | "method" | "get" | "set";
  computed: boolean;
  static: boolean;
  decorators: [ Decorator ];
}

ClassPrivateMethod

interface ClassPrivateMethod <: Function {
  type: "ClassPrivateMethod";
  key: PrivateName;
  kind: "method" | "get" | "set";
  static: boolean;
  decorators: [ Decorator ];
}

ClassProperty

interface ClassProperty <: Node {
  type: "ClassProperty";
  key: Expression;
  value: Expression;
  static: boolean;
  computed: boolean;
}

ClassPrivateProperty

interface ClassPrivateProperty <: Node {
  type: "ClassPrivateProperty";
  key: PrivateName;
  value: Expression;
  static: boolean;
}

ClassDeclaration

interface ClassDeclaration <: Class, Declaration {
  type: "ClassDeclaration";
  id: Identifier;
}

ClassExpression

interface ClassExpression <: Class, Expression {
  type: "ClassExpression";
}

MetaProperty

interface MetaProperty <: Expression {
  type: "MetaProperty";
  meta: Identifier;
  property: Identifier;
}

Modules

ModuleDeclaration

interface ModuleDeclaration <: Node { }

A module import or export declaration.

ModuleSpecifier

interface ModuleSpecifier <: Node {
  local: Identifier;
}

A specifier in an import or export declaration.

Imports

ImportDeclaration

interface ImportDeclaration <: ModuleDeclaration {
  type: "ImportDeclaration";
  importKind: null | "type" | "typeof" | "value";
  specifiers: [ ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier ];
  source: Literal;
  attributes?: [ ImportAttribute ];
}

An import declaration, e.g., import foo from "mod";.

importKind is only set when flow plugin enabled in babel-parser

ImportSpecifier

interface ImportSpecifier <: ModuleSpecifier {
  type: "ImportSpecifier";
  imported: Identifier;
}

An imported variable binding, e.g., {foo} in import {foo} from "mod" or {foo as bar} in import {foo as bar} from "mod". The imported field refers to the name of the export imported from the module. The local field refers to the binding imported into the local module scope. If it is a basic named import, such as in import {foo} from "mod", both imported and local are equivalent Identifier nodes; in this case an Identifier node representing foo. If it is an aliased import, such as in import {foo as bar} from "mod", the imported field is an Identifier node representing foo, and the local field is an Identifier node representing bar.

ImportDefaultSpecifier

interface ImportDefaultSpecifier <: ModuleSpecifier {
  type: "ImportDefaultSpecifier";
}

A default import specifier, e.g., foo in import foo from "mod.js".

ImportNamespaceSpecifier

interface ImportNamespaceSpecifier <: ModuleSpecifier {
  type: "ImportNamespaceSpecifier";
}

A namespace import specifier, e.g., * as foo in import * as foo from "mod.js".

ImportAttribute

interface ImportAttribute <: Node {
  type: "ImportAttribute";
  key: Identifier;
  value: StringLiteral;
}

An attribute specified on the ImportDeclaration.

Exports

ExportNamedDeclaration

interface ExportNamedDeclaration <: ModuleDeclaration {
  type: "ExportNamedDeclaration";
  declaration: Declaration | null;
  specifiers: [ ExportSpecifier ];
  source: Literal | null;
}

An export named declaration, e.g., export {foo, bar};, export {foo} from "mod";, export var foo = 1; or export * as foo from "bar";.

Note: Having declaration populated with non-empty specifiers or non-null source results in an invalid state.

ExportSpecifier

interface ExportSpecifier <: ModuleSpecifier {
  type: "ExportSpecifier";
  exported: Identifier;
  local?: Identifier;
}

An exported variable binding, e.g., {foo} in export {foo} or {bar as foo} in export {bar as foo}. The exported field refers to the name exported in the module. The local field refers to the binding into the local module scope. If it is a basic named export, such as in export {foo}, both exported and local are equivalent Identifier nodes; in this case an Identifier node representing foo. If it is an aliased export, such as in export {bar as foo}, the exported field is an Identifier node representing foo, and the local field is an Identifier node representing bar.

ExportDefaultDeclaration

interface OptFunctionDeclaration <: FunctionDeclaration {
  id: Identifier | null;
}

interface OptClassDeclaration <: ClassDeclaration {
  id: Identifier | null;
}

interface ExportDefaultDeclaration <: ModuleDeclaration {
  type: "ExportDefaultDeclaration";
  declaration: OptFunctionDeclaration | OptClassDeclaration | Expression;
}

An export default declaration, e.g., export default function () {}; or export default 1;.

ExportAllDeclaration

interface ExportAllDeclaration <: ModuleDeclaration {
  type: "ExportAllDeclaration";
  source: Literal;
}

An export batch declaration, e.g., export * from "mod";.