es2022.md

This document specifies the extensions to the core ESTree AST types to support the ES2022 grammar.

Classes

These language extensions cover following class features proposals:

• Class Fields
• Static Class Features
• Private Methods
• Static Initialization Blocks.

ClassBody

extend interface ClassBody {
    body: [ MethodDefinition | PropertyDefinition | StaticBlock ];
}

PropertyDefinition

interface PropertyDefinition <: Node {
    type: "PropertyDefinition";
    key: Expression | PrivateIdentifier;
    value: Expression | null;
    computed: boolean;
    static: boolean;
}

• When key is a PrivateIdentifier, computed must be false.

MethodDefinition

extend interface MethodDefinition {
    key: Expression | PrivateIdentifier;
}

• When key is a PrivateIdentifier, computed must be false and kind can not be "constructor".

PrivateIdentifier

interface PrivateIdentifier <: Node {
    type: "PrivateIdentifier";
    name: string;
}

A private identifier refers to private class elements. For a private name #a, its name is a.

extend interface MemberExpression {
    property: Expression | PrivateIdentifier;
}

• When property is a PrivateIdentifier, computed must be false.
• When object is a Super, property can not be a PrivateIdentifier.

StaticBlock

interface StaticBlock <: BlockStatement {
    type: "StaticBlock";
}

A static block static { } is a block statement serving as an additional static initializer.

Expressions

BinaryExpression

extend interface BinaryExpression <: Expression {
    left: Expression | PrivateIdentifier;
}

• left can be a private identifier (e.g. #foo) when operator is "in".
• See Ergonomic brand checks for Private Fields for details.

Modules

See Arbitrary module namespace identifier names for more details.

Imports

ImportSpecifier

extend interface ImportSpecifier <: ModuleSpecifier {
    imported: Identifier | Literal;
}

If imported is a Literal, imported.value must be a string without lone surrogate.

Exports

ExportSpecifier

extend interface ExportSpecifier <: ModuleSpecifier {
    local: Identifier | Literal;
    exported: Identifier | Literal;
}

local can be Literal only if the source of the ExportNamedDeclaration of the parent of this node is not null. e.g. export { "foo" as "foo" } from "mod" is valid, export { "foo" as "foo" } is invalid.

If exported/local is Literal, exported.value/local.value must be a string without lone surrogate.

ExportAllDeclaration

extend interface ExportAllDeclaration {
    exported: Identifier | Literal | null;
}

If exported is Literal, exported.value must be a string without lone surrogate.