}

function checkGrammarDecorators(node: Node): boolean {

return grammarErrorOnFirstToken(node, Diagnostics.Decorators_are_not_valid_here);

}

if (!canHaveDecorators(node) || !hasDecorators(node)) {

node.transformFlags = propagateChildFlags(body) | TransformFlags.ContainsClassFields;

// The following properties are used only to report grammar errors

node.modifiers = undefined;

return node;

}

function finishUpdateClassStaticBlockDeclaration(updated: Mutable<ClassStaticBlockDeclaration>, original: ClassStaticBlockDeclaration) {

if (updated !== original) {

updated.modifiers = original.modifiers;

}

return update(updated, original);

node.transformFlags |= TransformFlags.ContainsES2015;

// The following properties are used only to report grammar errors

node.typeParameters = undefined;

node.type = undefined;

return node;

function finishUpdateConstructorDeclaration(updated: Mutable<ConstructorDeclaration>, original: ConstructorDeclaration) {

if (updated !== original) {

updated.typeParameters = original.typeParameters;

updated.type = original.type;

}

}

// The following properties are used only to report grammar errors

return node;

}

function finishUpdateFunctionDeclaration(updated: Mutable<FunctionDeclaration>, original: FunctionDeclaration) {

if (updated !== original) {

// copy children used only for error reporting

}

return finishUpdateBaseSignatureDeclaration(updated, original);

}

node.transformFlags = TransformFlags.ContainsTypeScript;

// The following properties are used only to report grammar errors

return node;

}

function finishUpdateInterfaceDeclaration(updated: Mutable<InterfaceDeclaration>, original: InterfaceDeclaration) {

if (updated !== original) {

}

return update(updated, original);

}

node.transformFlags = TransformFlags.ContainsTypeScript;

// The following properties are used only to report grammar errors

return node;

}

function finishUpdateTypeAliasDeclaration(updated: Mutable<TypeAliasDeclaration>, original: TypeAliasDeclaration) {

if (updated !== original) {

}

return update(updated, original);

}

node.transformFlags &= ~TransformFlags.ContainsPossibleTopLevelAwait; // Enum declarations cannot contain `await`

// The following properties are used only to report grammar errors

return node;

}

function finishUpdateEnumDeclaration(updated: Mutable<EnumDeclaration>, original: EnumDeclaration) {

if (updated !== original) {

}

return update(updated, original);

}

node.transformFlags &= ~TransformFlags.ContainsPossibleTopLevelAwait; // Module declarations cannot contain `await`.

// The following properties are used only to report grammar errors

return node;

}

function finishUpdateModuleDeclaration(updated: Mutable<ModuleDeclaration>, original: ModuleDeclaration) {

if (updated !== original) {

}

return update(updated, original);

}

node.transformFlags = TransformFlags.ContainsTypeScript;

// The following properties are used only to report grammar errors

node.modifiers = undefined;

return node;

}

function finishUpdateNamespaceExportDeclaration(updated: Mutable<NamespaceExportDeclaration>, original: NamespaceExportDeclaration) {

if (updated !== original) {

updated.modifiers = original.modifiers;

}

return update(updated, original);

node.transformFlags &= ~TransformFlags.ContainsPossibleTopLevelAwait; // Import= declaration is always parsed in an Await context

// The following properties are used only to report grammar errors

return node;

}

function finishUpdateImportEqualsDeclaration(updated: Mutable<ImportEqualsDeclaration>, original: ImportEqualsDeclaration) {

if (updated !== original) {

}

return update(updated, original);

}

node.transformFlags &= ~TransformFlags.ContainsPossibleTopLevelAwait; // always parsed in an Await context

// The following properties are used only to report grammar errors

return node;

}

function finishUpdateImportDeclaration(updated: Mutable<ImportDeclaration>, original: ImportDeclaration) {

if (updated !== original) {

}

return update(updated, original);

}

node.transformFlags &= ~TransformFlags.ContainsPossibleTopLevelAwait; // always parsed in an Await context

// The following properties are used only to report grammar errors

return node;

}

function finishUpdateExportAssignment(updated: Mutable<ExportAssignment>, original: ExportAssignment) {

if (updated !== original) {

}

return update(updated, original);

}

node.transformFlags &= ~TransformFlags.ContainsPossibleTopLevelAwait; // always parsed in an Await context

// The following properties are used only to report grammar errors

return node;

}

function finishUpdateExportDeclaration(updated: Mutable<ExportDeclaration>, original: ExportDeclaration) {

if (updated !== original) {

}

return update(updated, original);

}

propagateChildFlags(node.initializer);

// The following properties are used only to report grammar errors

node.modifiers = undefined;

node.questionToken = undefined;

node.exclamationToken = undefined;

function finishUpdatePropertyAssignment(updated: Mutable<PropertyAssignment>, original: PropertyAssignment) {

// copy children used only for error reporting

if (updated !== original) {

updated.modifiers = original.modifiers;

updated.questionToken = original.questionToken;

updated.exclamationToken = original.exclamationToken;

// The following properties are used only to report grammar errors

node.equalsToken = undefined;

node.modifiers = undefined;

node.questionToken = undefined;

node.exclamationToken = undefined;

if (updated !== original) {

// copy children used only for error reporting

updated.equalsToken = original.equalsToken;

updated.modifiers = original.modifiers;

updated.questionToken = original.questionToken;

updated.exclamationToken = original.exclamationToken;