tsc-ts 0.0.4 → 0.0.5

package/dist/api/compiler/checker-grammar.js

@@ -0,0 +1,2573 @@
+// Grammar checks: errors for syntax the parser accepts but the language disallows.
+//
+// `checkGrammarSourceFile` walks a file once after it is type checked and runs the grammar checks
+// of each node in the order tsgo's checker runs them. Checks that need types read the checker's
+// caches. Errors reported with `grammarError*` are dropped when the file has parse errors.
+import { ElementAccessExpression, Identifier, NodeVisitor, StringLiteral, getAsteriskToken, getBody, getElements, getExpression, getHeritageClauses, getInitializer, getLabel, getIsTypeOnly, getLocals, getMembers, getModifiers, getName, getNodeId, getParameters, getPostfixToken, getStatements, getText, getType, getTypeArguments, getTypeParameters, isDeclarationNode, } from './ast.js';
+import { canHaveDecorators, canHaveIllegalDecorators, getExternalModuleName, getTextOfNodeFromSourceText, isAmbientModule, isFunctionLike, isFunctionLikeDeclarationKind, isModifierKind, isStringLiteralLike, modifierToFlag, nodeIsPresent, isInJSFile, } from './ast-utilities.js';
+import { getCombinedModifierFlags, getCombinedNodeFlags, getContainingClass, getRangeOfTokenAtPosition, getSourceFileOfNode, hasSyntacticModifier, isAutoAccessorPropertyDeclaration, isClassLike, isDynamicName, isEntityNameExpression, isExternalModule, isInTopLevelContext, isModuleAugmentationExternal, isPrivateIdentifierClassElementDeclaration, isStatic, skipParentheses, } from './binder-utilities.js';
+import { findUseStrictPrologue } from './binder.js';
+import { createDiagnosticForNode } from './checker.js';
+import { checkComputedPropertyName, checkExpressionCached, getTypeOfExpression } from './checker-expressions.js';
+import { isArrayLikeType } from './checker-members.js';
+import { getNullableType } from './checker-symbol-types.js';
+import { getTupleElementFlags, getTypeFromTypeNode } from './checker-type-nodes.js';
+import { isArrayType, isTupleType, tupleTargetOf } from './checker-type-factory.js';
+import { isGenericType } from './checker-type-operators.js';
+import { getPropertyNameFromType, isTypeUsableAsPropertyName, isValidIndexKeyType } from './checker-utilities.js';
+import { getSymbolOfDeclaration, resolveAlias } from './checker-symbols.js';
+import { Diagnostic, messageCategory } from './diagnostics.js';
+import { ModuleKind, ScriptTarget, getEmitModuleKind } from './options.js';
+import { fileExtensionIsOneOf, isExternalModuleNameRelative } from './path.js';
+import { SourceFileMetadata, getEmitModuleFormatOfFile, getImpliedNodeFormatForEmit } from './program-utilities.js';
+import { Scanner, ScannerErrorReporter, computeLineOfPosition, skipTrivia, tokenToString } from './scanner.js';
+import { typeToString } from './type-printer.js';
+import { findMismatchedAugmentsTag } from './checker-jsdoc.js';
+/** Runs the grammar checks of every node of `file`. */
+export function checkGrammarSourceFile(c, file) {
+    const g = new GrammarChecker(c, file);
+    if ((file.flags & 8388608 /* NodeFlags.Ambient */) !== 0)
+        checkGrammarTopLevelElementsForRequiredDeclareModifier(g, file);
+    file.forEachChild(g);
+}
+/** The grammar checker of the file of `node`, for grammar checks run while checking expressions. */
+function grammarCheckerOf(c, node) {
+    const file = getSourceFileOfNode(node);
+    const cached = c.grammarChecker;
+    if (cached !== undefined && cached.file === file)
+        return cached;
+    const g = new GrammarChecker(c, file);
+    c.grammarChecker = g;
+    return g;
+}
+/** Checks the grammar of an object literal each time it is checked, as tsgo does. */
+export function checkGrammarObjectLiteralOfExpression(c, node, inDestructuring) {
+    checkGrammarObjectLiteralExpression(grammarCheckerOf(c, node), node, inDestructuring);
+}
+/** Reports a trailing comma after the rest element of a destructuring assignment. */
+export function checkGrammarRestTrailingComma(c, node, list) {
+    checkGrammarForDisallowedTrailingComma(grammarCheckerOf(c, node), list, 9 /* Diagnostics.A_rest_parameter_or_binding_pattern_may_not_have_a_trailing_comma */);
+}
+/** Checks the grammar of a function expression or arrow function each time it is checked. */
+export function checkGrammarFunctionExpression(c, node) {
+    const g = grammarCheckerOf(c, node);
+    if (!checkGrammarFunctionLikeDeclaration(g, node) && node.kind === 219 /* SyntaxKind.FunctionExpression */)
+        checkGrammarForGenerator(g, node);
+}
+/** Checks the grammar of an `await` expression each time it is checked. */
+export function checkGrammarAwaitExpression(c, node) {
+    checkGrammarAwaitOrAwaitUsing(grammarCheckerOf(c, node), node);
+}
+/** Checks the grammar of a `yield` expression each time it is checked. */
+export function checkGrammarYieldOfExpression(c, node) {
+    checkGrammarYieldExpression(grammarCheckerOf(c, node), node);
+}
+/** Per-file state of the grammar walk. */
+export class GrammarChecker extends NodeVisitor {
+    c;
+    file;
+    /** Grammar errors are only reported in files without parse errors. */
+    hasParseErrors;
+    moduleKind;
+    metadata;
+    legacyDecorators;
+    /** Blocks and statements that already reported a statement in an ambient context. */
+    reportedAmbientStatements = new Set();
+    scanner = undefined;
+    constructor(c, file) {
+        super();
+        this.c = c;
+        this.file = file;
+        this.hasParseErrors = file.diagnostics.length > 0;
+        this.moduleKind = getEmitModuleKind(c.compilerOptions);
+        this.metadata = c.host.getSourceFileMetadata(file) ?? new SourceFileMetadata('', '', ModuleKind.None);
+        this.legacyDecorators = c.compilerOptions.experimentalDecorators === true;
+    }
+    visitNode(node) {
+        if (checkGrammarNode(this, node))
+            node.forEachChild(this);
+        return false;
+    }
+    /** A scanner over the file's text, for rescanning tokens. */
+    getScanner() {
+        let scanner = this.scanner;
+        if (scanner === undefined) {
+            scanner = new Scanner(this.file.text);
+            scanner.setLanguageVariant(this.file.languageVariant);
+            // The scanner's target enum has the same values as the option's.
+            scanner.setScriptTarget(this.c.languageVersion);
+            this.scanner = scanner;
+        }
+        return scanner;
+    }
+}
+// ---- Reporting
+function grammarErrorOnNode(g, node, message, ...args) {
+    if (g.hasParseErrors)
+        return false;
+    g.c.error(node, message, ...args);
+    return true;
+}
+function grammarErrorOnFirstToken(g, node, message, ...args) {
+    if (g.hasParseErrors)
+        return false;
+    const range = getRangeOfTokenAtPosition(g.file, node.pos);
+    g.c.addDiagnostic(new Diagnostic(g.file.diagnosticFile(), range.pos, range.end, message, args));
+    return true;
+}
+function grammarErrorAtPos(g, start, length, message, ...args) {
+    if (g.hasParseErrors)
+        return false;
+    g.c.addDiagnostic(new Diagnostic(g.file.diagnosticFile(), start, start + length, message, args));
+    return true;
+}
+/** A diagnostic at the first token of `node`. */
+function diagnosticAtFirstToken(g, node, message) {
+    const range = getRangeOfTokenAtPosition(g.file, node.pos);
+    return new Diagnostic(g.file.diagnosticFile(), range.pos, range.end, message);
+}
+function addRelated(diagnostic, node, message) {
+    diagnostic.relatedInformation.push(createDiagnosticForNode(node, message, []));
+}
+// ---- Dispatch
+/** Runs the grammar checks of `node`; returns whether its children are checked too. */
+function checkGrammarNode(g, node) {
+    switch (node.kind) {
+        // Declarations and members
+        case 169 /* SyntaxKind.TypeParameter */: {
+            checkGrammarModifiers(g, node);
+            const expression = node.expression;
+            if (expression !== undefined)
+                grammarErrorOnFirstToken(g, expression, 79 /* Diagnostics.Type_expected */);
+            return true;
+        }
+        case 170 /* SyntaxKind.Parameter */:
+            checkGrammarModifiers(g, node);
+            checkGrammarDecorators(g, node);
+            return true;
+        case 172 /* SyntaxKind.PropertySignature */:
+            checkGrammarPropertyDeclaration(g, node);
+            return true;
+        case 173 /* SyntaxKind.PropertyDeclaration */:
+            checkGrammarPropertyDeclaration(g, node);
+            checkGrammarDecorators(g, node);
+            return true;
+        case 186 /* SyntaxKind.ConstructorType */:
+        case 185 /* SyntaxKind.FunctionType */:
+        case 180 /* SyntaxKind.CallSignature */:
+        case 181 /* SyntaxKind.ConstructSignature */:
+            checkGrammarFunctionLikeDeclaration(g, node);
+            return true;
+        case 182 /* SyntaxKind.IndexSignature */:
+            if (!checkGrammarModifiers(g, node))
+                checkGrammarIndexSignatureParameters(g, node);
+            return true;
+        case 175 /* SyntaxKind.MethodDeclaration */:
+        case 174 /* SyntaxKind.MethodSignature */:
+            checkGrammarMethodDeclaration(g, node);
+            return true;
+        case 176 /* SyntaxKind.ClassStaticBlockDeclaration */:
+            checkGrammarModifiers(g, node);
+            return true;
+        case 177 /* SyntaxKind.Constructor */:
+            checkGrammarFunctionLikeDeclaration(g, node);
+            if (!checkGrammarConstructorTypeParameters(g, node)) {
+                const type = node.type;
+                if (type !== undefined)
+                    grammarErrorOnNode(g, type, 62 /* Diagnostics.Type_annotation_cannot_appear_on_a_constructor_declaration */);
+            }
+            return true;
+        case 178 /* SyntaxKind.GetAccessor */:
+        case 179 /* SyntaxKind.SetAccessor */:
+            checkGrammarAccessorDeclaration(g, node);
+            return true;
+        case 263 /* SyntaxKind.FunctionDeclaration */:
+            checkGrammarDecorators(g, node);
+            checkGrammarFunctionLikeDeclaration(g, node);
+            checkGrammarForGenerator(g, node);
+            return true;
+        case 264 /* SyntaxKind.ClassDeclaration */:
+            checkGrammarClassDeclaration(g, node);
+            return true;
+        case 232 /* SyntaxKind.ClassExpression */:
+            checkGrammarClassLikeDeclaration(g, node);
+            return true;
+        case 265 /* SyntaxKind.InterfaceDeclaration */:
+            checkGrammarInterfaceDeclaration(g, node);
+            return true;
+        case 266 /* SyntaxKind.TypeAliasDeclaration */:
+            checkGrammarModifiers(g, node);
+            if (!containerAllowsBlockScopedVariable(node.parent))
+                grammarErrorOnNode(g, node, 116 /* Diagnostics.X_0_declarations_can_only_be_declared_inside_a_block */, 'type');
+            return true;
+        case 267 /* SyntaxKind.EnumDeclaration */:
+            checkGrammarModifiers(g, node);
+            return true;
+        case 268 /* SyntaxKind.ModuleDeclaration */:
+            return checkGrammarModuleDeclaration(g, node);
+        case 273 /* SyntaxKind.ImportDeclaration */:
+        case 346 /* SyntaxKind.JSImportDeclaration */:
+            checkGrammarImportDeclaration(g, node);
+            return false;
+        case 272 /* SyntaxKind.ImportEqualsDeclaration */:
+            checkGrammarImportEqualsDeclaration(g, node);
+            return false;
+        case 279 /* SyntaxKind.ExportDeclaration */:
+            checkGrammarExportDeclaration(g, node);
+            return false;
+        case 278 /* SyntaxKind.ExportAssignment */:
+            return checkGrammarExportAssignment(g, node);
+        case 261 /* SyntaxKind.VariableDeclaration */:
+            // Catch clause variables are checked with the clause.
+            if (node.parent.kind !== 300 /* SyntaxKind.CatchClause */)
+                checkGrammarVariableDeclaration(g, node);
+            return true;
+        case 209 /* SyntaxKind.BindingElement */:
+            checkGrammarBindingElement(g, node);
+            return true;
+        // Statements
+        case 242 /* SyntaxKind.Block */:
+        case 243 /* SyntaxKind.EmptyStatement */:
+        case 260 /* SyntaxKind.DebuggerStatement */:
+        case 245 /* SyntaxKind.ExpressionStatement */:
+        case 247 /* SyntaxKind.DoStatement */:
+        case 248 /* SyntaxKind.WhileStatement */:
+        case 259 /* SyntaxKind.TryStatement */:
+            checkGrammarStatementInAmbientContext(g, node);
+            return true;
+        case 246 /* SyntaxKind.IfStatement */: {
+            checkGrammarStatementInAmbientContext(g, node);
+            return true;
+        }
+        case 244 /* SyntaxKind.VariableStatement */:
+            checkGrammarVariableStatement(g, node);
+            return true;
+        case 249 /* SyntaxKind.ForStatement */: {
+            const initializer = node.initializer;
+            if (!checkGrammarStatementInAmbientContext(g, node) &&
+                initializer !== undefined &&
+                initializer.kind === 262 /* SyntaxKind.VariableDeclarationList */)
+                checkGrammarVariableDeclarationList(g, initializer);
+            return true;
+        }
+        case 250 /* SyntaxKind.ForInStatement */:
+        case 251 /* SyntaxKind.ForOfStatement */:
+            checkGrammarForInOrForOfStatement(g, node);
+            return true;
+        case 253 /* SyntaxKind.BreakStatement */:
+        case 252 /* SyntaxKind.ContinueStatement */:
+            if (!checkGrammarStatementInAmbientContext(g, node))
+                checkGrammarBreakOrContinueStatement(g, node);
+            return true;
+        case 254 /* SyntaxKind.ReturnStatement */:
+            return checkGrammarReturnStatement(g, node);
+        case 255 /* SyntaxKind.WithStatement */:
+            checkGrammarWithStatement(g, node);
+            return false;
+        case 256 /* SyntaxKind.SwitchStatement */:
+            checkGrammarSwitchStatement(g, node);
+            return true;
+        case 257 /* SyntaxKind.LabeledStatement */:
+            checkGrammarLabeledStatement(g, node);
+            return true;
+        case 258 /* SyntaxKind.ThrowStatement */: {
+            const expression = node.expression;
+            if (!checkGrammarStatementInAmbientContext(g, node) &&
+                expression instanceof Identifier &&
+                expression.text.length === 0)
+                grammarErrorAtPos(g, expression.pos, 0, 108 /* Diagnostics.Line_break_not_permitted_here */);
+            return true;
+        }
+        case 300 /* SyntaxKind.CatchClause */:
+            checkGrammarCatchClause(g, node);
+            return true;
+        // Type nodes
+        case 184 /* SyntaxKind.TypeReference */:
+            checkGrammarTypeReference(g, node);
+            return true;
+        case 187 /* SyntaxKind.TypeQuery */:
+            checkGrammarTypeArguments(g, getTypeArguments(node));
+            return true;
+        case 199 /* SyntaxKind.TypeOperator */:
+            checkGrammarTypeOperatorNode(g, node);
+            return true;
+        case 196 /* SyntaxKind.InferType */:
+            checkGrammarInferType(g, node);
+            return true;
+        case 206 /* SyntaxKind.ImportType */: {
+            const attributes = node.attributes;
+            if (attributes !== undefined)
+                getResolutionModeOverride(g, attributes, true);
+            return true;
+        }
+        case 190 /* SyntaxKind.TupleType */:
+            checkGrammarTupleType(g, node);
+            return true;
+        case 203 /* SyntaxKind.NamedTupleMember */:
+            checkGrammarNamedTupleMember(g, node);
+            return true;
+        case 312 /* SyntaxKind.JSDocNonNullableType */:
+        case 311 /* SyntaxKind.JSDocNullableType */:
+        case 310 /* SyntaxKind.JSDocAllType */:
+        case 317 /* SyntaxKind.JSDocTypeLiteral */:
+            checkGrammarJSDocTypeInTypeScript(g, node);
+            return true;
+        case 201 /* SyntaxKind.MappedType */: {
+            const members = node.members;
+            if (members !== undefined && members.nodes.length > 0)
+                grammarErrorOnNode(g, members.nodes[0], 1732 /* Diagnostics.A_mapped_type_may_not_declare_properties_or_methods */);
+            return true;
+        }
+        // Expressions
+        case 234 /* SyntaxKind.ExpressionWithTypeArguments */:
+            // Heritage clause elements are checked with their class or interface.
+            if (node.parent.kind !== 299 /* SyntaxKind.HeritageClause */)
+                checkGrammarExpressionWithTypeArguments(g, node);
+            return true;
+        case 219 /* SyntaxKind.FunctionExpression */:
+        case 220 /* SyntaxKind.ArrowFunction */:
+            // Checked by the checker each time the function is checked.
+            return true;
+        case 211 /* SyntaxKind.ObjectLiteralExpression */:
+            // Checked by the checker each time the literal is checked.
+            return true;
+        case 214 /* SyntaxKind.CallExpression */:
+            checkGrammarCallExpression(g, node);
+            return true;
+        case 215 /* SyntaxKind.NewExpression */:
+            checkGrammarTypeArguments(g, getTypeArguments(node));
+            return true;
+        case 216 /* SyntaxKind.TaggedTemplateExpression */:
+            if (!checkGrammarTaggedTemplateChain(g, node))
+                checkGrammarTypeArguments(g, getTypeArguments(node));
+            return true;
+        case 237 /* SyntaxKind.MetaProperty */:
+            checkGrammarMetaProperty(g, node);
+            return true;
+        case 224 /* SyntaxKind.AwaitExpression */:
+        case 230 /* SyntaxKind.YieldExpression */:
+        case 227 /* SyntaxKind.BinaryExpression */:
+            // Checked by the checker each time the expression is checked.
+            return true;
+        case 80 /* SyntaxKind.PrivateIdentifier */:
+            checkGrammarPrivateIdentifierExpression(g, node);
+            return false;
+        case 9 /* SyntaxKind.BigIntLiteral */:
+            checkGrammarBigIntLiteral(g, node);
+            return false;
+        case 13 /* SyntaxKind.RegularExpressionLiteral */:
+            checkGrammarRegularExpressionLiteral(g, node);
+            return false;
+        case 171 /* SyntaxKind.Decorator */: {
+            // Decorators are only checked on valid targets.
+            const target = node.parent;
+            return (canHaveDecorators(target) &&
+                nodeCanBeDecorated(g.legacyDecorators, target, target.parent, target.parent.parent));
+        }
+    }
+    return true;
+}
+// ---- Modifiers and decorators
+function checkGrammarModifiers(g, node) {
+    const modifiers = getModifiers(node);
+    if (modifiers === undefined)
+        return false;
+    if (reportObviousDecoratorErrors(g, node, modifiers) || reportObviousModifierErrors(g, node, modifiers))
+        return true;
+    if (isThisParameter(node))
+        return grammarErrorOnFirstToken(g, node, 359 /* Diagnostics.Neither_decorators_nor_modifiers_may_be_applied_to_this_parameters */);
+    const blockScopeKind = node.kind === 244 /* SyntaxKind.VariableStatement */
+        ? node.declarationList.flags & 7 /* NodeFlags.BlockScoped */
+        : 0 /* NodeFlags.None */;
+    const parent = node.parent;
+    let lastStatic;
+    let lastDeclare;
+    let lastAsync;
+    let lastOverride;
+    let firstDecorator;
+    let flags = 0 /* ModifierFlags.None */;
+    let sawExportBeforeDecorators = false;
+    // Decorators and modifiers come in four chunks: leading decorators, leading modifiers,
+    // trailing decorators and trailing modifiers. Leading and trailing decorators can't both appear.
+    let hasLeadingDecorators = false;
+    for (const modifier of modifiers.nodes) {
+        if (modifier.kind === 171 /* SyntaxKind.Decorator */) {
+            if (!nodeCanBeDecorated(g.legacyDecorators, node, parent, parent.parent)) {
+                if (node.kind === 175 /* SyntaxKind.MethodDeclaration */ && !nodeIsPresent(getBody(node)))
+                    return grammarErrorOnFirstToken(g, node, 199 /* Diagnostics.A_decorator_can_only_decorate_a_method_implementation_not_an_overload */);
+                return grammarErrorOnFirstToken(g, node, 160 /* Diagnostics.Decorators_are_not_valid_here */);
+            }
+            else if (g.legacyDecorators && (node.kind === 178 /* SyntaxKind.GetAccessor */ || node.kind === 179 /* SyntaxKind.SetAccessor */)) {
+                const first = getFirstAccessorOfPair(g.c, node);
+                if (first !== node && hasDecorators(first))
+                    return grammarErrorOnFirstToken(g, node, 161 /* Diagnostics.Decorators_cannot_be_applied_to_multiple_get_Slashset_accessors_of_the_same_name */);
+            }
+            // Decorators can only follow `export` and `default`.
+            if ((flags & ~(2080 /* ModifierFlags.ExportDefault */ | 32768 /* ModifierFlags.Decorator */)) !== 0)
+                return grammarErrorOnNode(g, modifier, 160 /* Diagnostics.Decorators_are_not_valid_here */);
+            if (hasLeadingDecorators && (flags & 98303 /* ModifierFlags.Modifier */) !== 0) {
+                if (g.hasParseErrors)
+                    return false;
+                const diagnostic = g.c.error(modifier, 1767 /* Diagnostics.Decorators_may_not_appear_after_export_or_export_default_if_they_also_appear_before_export */);
+                addRelated(diagnostic, firstDecorator, 401 /* Diagnostics.Decorator_used_before_export_here */);
+                return true;
+            }
+            flags |= 32768 /* ModifierFlags.Decorator */;
+            if ((flags & 98303 /* ModifierFlags.Modifier */) === 0)
+                hasLeadingDecorators = true;
+            else if ((flags & 32 /* ModifierFlags.Export */) !== 0)
+                sawExportBeforeDecorators = true;
+            if (firstDecorator === undefined)
+                firstDecorator = modifier;
+            continue;
+        }
+        const kind = modifier.kind;
+        const reparsed = (modifier.flags & 8 /* NodeFlags.Reparsed */) !== 0;
+        if (kind !== 148 /* SyntaxKind.ReadonlyKeyword */) {
+            if (node.kind === 172 /* SyntaxKind.PropertySignature */ || node.kind === 174 /* SyntaxKind.MethodSignature */)
+                return grammarErrorOnNode(g, modifier, 54 /* Diagnostics.X_0_modifier_cannot_appear_on_a_type_member */, tokenToString(kind));
+            if (node.kind === 182 /* SyntaxKind.IndexSignature */ && (kind !== 125 /* SyntaxKind.StaticKeyword */ || !isClassLike(parent)))
+                return grammarErrorOnNode(g, modifier, 55 /* Diagnostics.X_0_modifier_cannot_appear_on_an_index_signature */, tokenToString(kind));
+        }
+        if (kind !== 102 /* SyntaxKind.InKeyword */ &&
+            kind !== 147 /* SyntaxKind.OutKeyword */ &&
+            kind !== 86 /* SyntaxKind.ConstKeyword */ &&
+            node.kind === 169 /* SyntaxKind.TypeParameter */)
+            return grammarErrorOnNode(g, modifier, 222 /* Diagnostics.X_0_modifier_cannot_appear_on_a_type_parameter */, tokenToString(kind));
+        switch (kind) {
+            case 86 /* SyntaxKind.ConstKeyword */:
+                if (node.kind !== 267 /* SyntaxKind.EnumDeclaration */ && node.kind !== 169 /* SyntaxKind.TypeParameter */)
+                    return grammarErrorOnNode(g, node, 198 /* Diagnostics.A_class_member_cannot_have_the_0_keyword */, tokenToString(kind));
+                if (node.kind === 169 /* SyntaxKind.TypeParameter */ && !isConstTypeParameterContainer(parent))
+                    return grammarErrorOnNode(g, modifier, 226 /* Diagnostics.X_0_modifier_can_only_appear_on_a_type_parameter_of_a_function_method_or_class */, tokenToString(kind));
+                break;
+            case 164 /* SyntaxKind.OverrideKeyword */:
+                // Parameters that aren't parameter properties are reported by the parameter check.
+                if ((flags & 16 /* ModifierFlags.Override */) !== 0)
+                    return grammarErrorOnNode(g, modifier, 23 /* Diagnostics.X_0_modifier_already_seen */, 'override');
+                if ((flags & 128 /* ModifierFlags.Ambient */) !== 0)
+                    return grammarErrorOnNode(g, modifier, 193 /* Diagnostics.X_0_modifier_cannot_be_used_with_1_modifier */, 'override', 'declare');
+                if ((flags & 8 /* ModifierFlags.Readonly */) !== 0 && !reparsed)
+                    return grammarErrorOnNode(g, modifier, 22 /* Diagnostics.X_0_modifier_must_precede_1_modifier */, 'override', 'readonly');
+                if ((flags & 512 /* ModifierFlags.Accessor */) !== 0 && !reparsed)
+                    return grammarErrorOnNode(g, modifier, 22 /* Diagnostics.X_0_modifier_must_precede_1_modifier */, 'override', 'accessor');
+                if ((flags & 1024 /* ModifierFlags.Async */) !== 0 && !reparsed)
+                    return grammarErrorOnNode(g, modifier, 22 /* Diagnostics.X_0_modifier_must_precede_1_modifier */, 'override', 'async');
+                flags |= 16 /* ModifierFlags.Override */;
+                lastOverride = modifier;
+                break;
+            case 124 /* SyntaxKind.PublicKeyword */:
+            case 123 /* SyntaxKind.ProtectedKeyword */:
+            case 122 /* SyntaxKind.PrivateKeyword */: {
+                const text = tokenToString(kind);
+                if ((flags & 7 /* ModifierFlags.AccessibilityModifier */) !== 0)
+                    return grammarErrorOnNode(g, modifier, 21 /* Diagnostics.Accessibility_modifier_already_seen */);
+                if ((flags & 16 /* ModifierFlags.Override */) !== 0 && !reparsed)
+                    return grammarErrorOnNode(g, modifier, 22 /* Diagnostics.X_0_modifier_must_precede_1_modifier */, text, 'override');
+                if ((flags & 256 /* ModifierFlags.Static */) !== 0 && !reparsed)
+                    return grammarErrorOnNode(g, modifier, 22 /* Diagnostics.X_0_modifier_must_precede_1_modifier */, text, 'static');
+                if ((flags & 512 /* ModifierFlags.Accessor */) !== 0 && !reparsed)
+                    return grammarErrorOnNode(g, modifier, 22 /* Diagnostics.X_0_modifier_must_precede_1_modifier */, text, 'accessor');
+                if ((flags & 8 /* ModifierFlags.Readonly */) !== 0 && !reparsed)
+                    return grammarErrorOnNode(g, modifier, 22 /* Diagnostics.X_0_modifier_must_precede_1_modifier */, text, 'readonly');
+                if ((flags & 1024 /* ModifierFlags.Async */) !== 0 && !reparsed)
+                    return grammarErrorOnNode(g, modifier, 22 /* Diagnostics.X_0_modifier_must_precede_1_modifier */, text, 'async');
+                if (parent.kind === 269 /* SyntaxKind.ModuleBlock */ || parent.kind === 307 /* SyntaxKind.SourceFile */)
+                    return grammarErrorOnNode(g, modifier, 32 /* Diagnostics.X_0_modifier_cannot_appear_on_a_module_or_namespace_element */, text);
+                if ((flags & 64 /* ModifierFlags.Abstract */) !== 0) {
+                    if (kind === 122 /* SyntaxKind.PrivateKeyword */)
+                        return grammarErrorOnNode(g, modifier, 193 /* Diagnostics.X_0_modifier_cannot_be_used_with_1_modifier */, text, 'abstract');
+                    if (!reparsed)
+                        return grammarErrorOnNode(g, modifier, 22 /* Diagnostics.X_0_modifier_must_precede_1_modifier */, text, 'abstract');
+                }
+                else if (isPrivateIdentifierClassElementDeclaration(node))
+                    return grammarErrorOnNode(g, modifier, 1832 /* Diagnostics.An_accessibility_modifier_cannot_be_used_with_a_private_identifier */);
+                flags |= modifierToFlag(kind);
+                break;
+            }
+            case 125 /* SyntaxKind.StaticKeyword */:
+                if ((flags & 256 /* ModifierFlags.Static */) !== 0)
+                    return grammarErrorOnNode(g, modifier, 23 /* Diagnostics.X_0_modifier_already_seen */, 'static');
+                if ((flags & 8 /* ModifierFlags.Readonly */) !== 0 && !reparsed)
+                    return grammarErrorOnNode(g, modifier, 22 /* Diagnostics.X_0_modifier_must_precede_1_modifier */, 'static', 'readonly');
+                if ((flags & 1024 /* ModifierFlags.Async */) !== 0 && !reparsed)
+                    return grammarErrorOnNode(g, modifier, 22 /* Diagnostics.X_0_modifier_must_precede_1_modifier */, 'static', 'async');
+                if ((flags & 512 /* ModifierFlags.Accessor */) !== 0 && !reparsed)
+                    return grammarErrorOnNode(g, modifier, 22 /* Diagnostics.X_0_modifier_must_precede_1_modifier */, 'static', 'accessor');
+                if (parent.kind === 269 /* SyntaxKind.ModuleBlock */ || parent.kind === 307 /* SyntaxKind.SourceFile */)
+                    return grammarErrorOnNode(g, modifier, 32 /* Diagnostics.X_0_modifier_cannot_appear_on_a_module_or_namespace_element */, 'static');
+                if (node.kind === 170 /* SyntaxKind.Parameter */)
+                    return grammarErrorOnNode(g, modifier, 59 /* Diagnostics.X_0_modifier_cannot_appear_on_a_parameter */, 'static');
+                if ((flags & 64 /* ModifierFlags.Abstract */) !== 0)
+                    return grammarErrorOnNode(g, modifier, 193 /* Diagnostics.X_0_modifier_cannot_be_used_with_1_modifier */, 'static', 'abstract');
+                if ((flags & 16 /* ModifierFlags.Override */) !== 0 && !reparsed)
+                    return grammarErrorOnNode(g, modifier, 22 /* Diagnostics.X_0_modifier_must_precede_1_modifier */, 'static', 'override');
+                flags |= 256 /* ModifierFlags.Static */;
+                lastStatic = modifier;
+                break;
+            case 128 /* SyntaxKind.AccessorKeyword */:
+                if ((flags & 512 /* ModifierFlags.Accessor */) !== 0)
+                    return grammarErrorOnNode(g, modifier, 23 /* Diagnostics.X_0_modifier_already_seen */, 'accessor');
+                if ((flags & 8 /* ModifierFlags.Readonly */) !== 0)
+                    return grammarErrorOnNode(g, modifier, 193 /* Diagnostics.X_0_modifier_cannot_be_used_with_1_modifier */, 'accessor', 'readonly');
+                if ((flags & 128 /* ModifierFlags.Ambient */) !== 0)
+                    return grammarErrorOnNode(g, modifier, 193 /* Diagnostics.X_0_modifier_cannot_be_used_with_1_modifier */, 'accessor', 'declare');
+                if (node.kind !== 173 /* SyntaxKind.PropertyDeclaration */)
+                    return grammarErrorOnNode(g, modifier, 224 /* Diagnostics.X_accessor_modifier_can_only_appear_on_a_property_declaration */);
+                flags |= 512 /* ModifierFlags.Accessor */;
+                break;
+            case 148 /* SyntaxKind.ReadonlyKeyword */:
+                if ((flags & 8 /* ModifierFlags.Readonly */) !== 0)
+                    return grammarErrorOnNode(g, modifier, 23 /* Diagnostics.X_0_modifier_already_seen */, 'readonly');
+                // Parameters that aren't parameter properties are reported by the parameter check.
+                if (node.kind !== 173 /* SyntaxKind.PropertyDeclaration */ &&
+                    node.kind !== 172 /* SyntaxKind.PropertySignature */ &&
+                    node.kind !== 182 /* SyntaxKind.IndexSignature */ &&
+                    node.kind !== 170 /* SyntaxKind.Parameter */)
+                    return grammarErrorOnNode(g, modifier, 19 /* Diagnostics.X_readonly_modifier_can_only_appear_on_a_property_declaration_or_index_signature */);
+                if ((flags & 512 /* ModifierFlags.Accessor */) !== 0)
+                    return grammarErrorOnNode(g, modifier, 193 /* Diagnostics.X_0_modifier_cannot_be_used_with_1_modifier */, 'readonly', 'accessor');
+                flags |= 8 /* ModifierFlags.Readonly */;
+                break;
+            case 94 /* SyntaxKind.ExportKeyword */:
+                if (g.c.compilerOptions.verbatimModuleSyntax === true &&
+                    (node.flags & 8388608 /* NodeFlags.Ambient */) === 0 &&
+                    node.kind !== 266 /* SyntaxKind.TypeAliasDeclaration */ &&
+                    node.kind !== 265 /* SyntaxKind.InterfaceDeclaration */ &&
+                    node.kind !== 268 /* SyntaxKind.ModuleDeclaration */ &&
+                    parent.kind === 307 /* SyntaxKind.SourceFile */ &&
+                    getEmitModuleFormat(g) === ModuleKind.CommonJS)
+                    return grammarErrorOnNode(g, modifier, 236 /* Diagnostics.A_top_level_export_modifier_cannot_be_used_on_value_declarations_in_a_CommonJS_module_when_verbatimModuleSyntax_is_enabled */);
+                if ((flags & 32 /* ModifierFlags.Export */) !== 0)
+                    return grammarErrorOnNode(g, modifier, 23 /* Diagnostics.X_0_modifier_already_seen */, 'export');
+                if ((flags & 128 /* ModifierFlags.Ambient */) !== 0 && !reparsed)
+                    return grammarErrorOnNode(g, modifier, 22 /* Diagnostics.X_0_modifier_must_precede_1_modifier */, 'export', 'declare');
+                if ((flags & 64 /* ModifierFlags.Abstract */) !== 0 && !reparsed)
+                    return grammarErrorOnNode(g, modifier, 22 /* Diagnostics.X_0_modifier_must_precede_1_modifier */, 'export', 'abstract');
+                if ((flags & 1024 /* ModifierFlags.Async */) !== 0 && !reparsed)
+                    return grammarErrorOnNode(g, modifier, 22 /* Diagnostics.X_0_modifier_must_precede_1_modifier */, 'export', 'async');
+                if (isClassLike(parent) && node.kind !== 345 /* SyntaxKind.JSTypeAliasDeclaration */)
+                    return grammarErrorOnNode(g, modifier, 24 /* Diagnostics.X_0_modifier_cannot_appear_on_class_elements_of_this_kind */, 'export');
+                if (node.kind === 170 /* SyntaxKind.Parameter */)
+                    return grammarErrorOnNode(g, modifier, 59 /* Diagnostics.X_0_modifier_cannot_appear_on_a_parameter */, 'export');
+                if (blockScopeKind === 4 /* NodeFlags.Using */)
+                    return grammarErrorOnNode(g, modifier, 406 /* Diagnostics.X_0_modifier_cannot_appear_on_a_using_declaration */, 'export');
+                if (blockScopeKind === 6 /* NodeFlags.AwaitUsing */)
+                    return grammarErrorOnNode(g, modifier, 410 /* Diagnostics.X_0_modifier_cannot_appear_on_an_await_using_declaration */, 'export');
+                flags |= 32 /* ModifierFlags.Export */;
+                break;
+            case 89 /* SyntaxKind.DefaultKeyword */: {
+                const container = parent.kind === 307 /* SyntaxKind.SourceFile */ ? parent : parent.parent;
+                if (container.kind === 268 /* SyntaxKind.ModuleDeclaration */ && !isAmbientModule(container))
+                    return grammarErrorOnNode(g, modifier, 255 /* Diagnostics.A_default_export_can_only_be_used_in_an_ECMAScript_style_module */);
+                if (blockScopeKind === 4 /* NodeFlags.Using */)
+                    return grammarErrorOnNode(g, modifier, 406 /* Diagnostics.X_0_modifier_cannot_appear_on_a_using_declaration */, 'default');
+                if (blockScopeKind === 6 /* NodeFlags.AwaitUsing */)
+                    return grammarErrorOnNode(g, modifier, 410 /* Diagnostics.X_0_modifier_cannot_appear_on_an_await_using_declaration */, 'default');
+                if ((flags & 32 /* ModifierFlags.Export */) === 0 && !reparsed)
+                    return grammarErrorOnNode(g, modifier, 22 /* Diagnostics.X_0_modifier_must_precede_1_modifier */, 'export', 'default');
+                if (sawExportBeforeDecorators)
+                    return grammarErrorOnNode(g, firstDecorator, 160 /* Diagnostics.Decorators_are_not_valid_here */);
+                flags |= 2048 /* ModifierFlags.Default */;
+                break;
+            }
+            case 137 /* SyntaxKind.DeclareKeyword */:
+                if ((flags & 128 /* ModifierFlags.Ambient */) !== 0)
+                    return grammarErrorOnNode(g, modifier, 23 /* Diagnostics.X_0_modifier_already_seen */, 'declare');
+                if ((flags & 1024 /* ModifierFlags.Async */) !== 0)
+                    return grammarErrorOnNode(g, modifier, 30 /* Diagnostics.X_0_modifier_cannot_be_used_in_an_ambient_context */, 'async');
+                if ((flags & 16 /* ModifierFlags.Override */) !== 0)
+                    return grammarErrorOnNode(g, modifier, 30 /* Diagnostics.X_0_modifier_cannot_be_used_in_an_ambient_context */, 'override');
+                if (isClassLike(parent) && node.kind !== 173 /* SyntaxKind.PropertyDeclaration */)
+                    return grammarErrorOnNode(g, modifier, 24 /* Diagnostics.X_0_modifier_cannot_appear_on_class_elements_of_this_kind */, 'declare');
+                if (node.kind === 170 /* SyntaxKind.Parameter */)
+                    return grammarErrorOnNode(g, modifier, 59 /* Diagnostics.X_0_modifier_cannot_appear_on_a_parameter */, 'declare');
+                if (blockScopeKind === 4 /* NodeFlags.Using */)
+                    return grammarErrorOnNode(g, modifier, 406 /* Diagnostics.X_0_modifier_cannot_appear_on_a_using_declaration */, 'declare');
+                if (blockScopeKind === 6 /* NodeFlags.AwaitUsing */)
+                    return grammarErrorOnNode(g, modifier, 410 /* Diagnostics.X_0_modifier_cannot_appear_on_an_await_using_declaration */, 'declare');
+                if ((parent.flags & 8388608 /* NodeFlags.Ambient */) !== 0 && parent.kind === 269 /* SyntaxKind.ModuleBlock */)
+                    return grammarErrorOnNode(g, modifier, 28 /* Diagnostics.A_declare_modifier_cannot_be_used_in_an_already_ambient_context */);
+                if (isPrivateIdentifierClassElementDeclaration(node))
+                    return grammarErrorOnNode(g, modifier, 1841 /* Diagnostics.X_0_modifier_cannot_be_used_with_a_private_identifier */, 'declare');
+                if ((flags & 512 /* ModifierFlags.Accessor */) !== 0)
+                    return grammarErrorOnNode(g, modifier, 193 /* Diagnostics.X_0_modifier_cannot_be_used_with_1_modifier */, 'declare', 'accessor');
+                flags |= 128 /* ModifierFlags.Ambient */;
+                lastDeclare = modifier;
+                break;
+            case 127 /* SyntaxKind.AbstractKeyword */: {
+                if ((flags & 64 /* ModifierFlags.Abstract */) !== 0)
+                    return grammarErrorOnNode(g, modifier, 23 /* Diagnostics.X_0_modifier_already_seen */, 'abstract');
+                if (node.kind !== 264 /* SyntaxKind.ClassDeclaration */ && node.kind !== 186 /* SyntaxKind.ConstructorType */) {
+                    if (node.kind !== 175 /* SyntaxKind.MethodDeclaration */ &&
+                        node.kind !== 173 /* SyntaxKind.PropertyDeclaration */ &&
+                        node.kind !== 178 /* SyntaxKind.GetAccessor */ &&
+                        node.kind !== 179 /* SyntaxKind.SetAccessor */)
+                        return grammarErrorOnNode(g, modifier, 192 /* Diagnostics.X_abstract_modifier_can_only_appear_on_a_class_method_or_property_declaration */);
+                    if (!(parent.kind === 264 /* SyntaxKind.ClassDeclaration */ && hasSyntacticModifier(parent, 64 /* ModifierFlags.Abstract */)))
+                        return grammarErrorOnNode(g, modifier, node.kind === 173 /* SyntaxKind.PropertyDeclaration */
+                            ? 203 /* Diagnostics.Abstract_properties_can_only_appear_within_an_abstract_class */
+                            : 194 /* Diagnostics.Abstract_methods_can_only_appear_within_an_abstract_class */);
+                    if ((flags & 256 /* ModifierFlags.Static */) !== 0)
+                        return grammarErrorOnNode(g, modifier, 193 /* Diagnostics.X_0_modifier_cannot_be_used_with_1_modifier */, 'static', 'abstract');
+                    if ((flags & 2 /* ModifierFlags.Private */) !== 0)
+                        return grammarErrorOnNode(g, modifier, 193 /* Diagnostics.X_0_modifier_cannot_be_used_with_1_modifier */, 'private', 'abstract');
+                    if ((flags & 1024 /* ModifierFlags.Async */) !== 0 && lastAsync !== undefined)
+                        return grammarErrorOnNode(g, lastAsync, 193 /* Diagnostics.X_0_modifier_cannot_be_used_with_1_modifier */, 'async', 'abstract');
+                    if ((flags & 16 /* ModifierFlags.Override */) !== 0 && !reparsed)
+                        return grammarErrorOnNode(g, modifier, 22 /* Diagnostics.X_0_modifier_must_precede_1_modifier */, 'abstract', 'override');
+                    if ((flags & 512 /* ModifierFlags.Accessor */) !== 0 && !reparsed)
+                        return grammarErrorOnNode(g, modifier, 22 /* Diagnostics.X_0_modifier_must_precede_1_modifier */, 'abstract', 'accessor');
+                }
+                const name = getName(node);
+                if (name !== undefined && name.kind === 80 /* SyntaxKind.PrivateIdentifier */)
+                    return grammarErrorOnNode(g, modifier, 1841 /* Diagnostics.X_0_modifier_cannot_be_used_with_a_private_identifier */, 'abstract');
+                flags |= 64 /* ModifierFlags.Abstract */;
+                break;
+            }
+            case 133 /* SyntaxKind.AsyncKeyword */:
+                if ((flags & 1024 /* ModifierFlags.Async */) !== 0)
+                    return grammarErrorOnNode(g, modifier, 23 /* Diagnostics.X_0_modifier_already_seen */, 'async');
+                if ((flags & 128 /* ModifierFlags.Ambient */) !== 0 || (parent.flags & 8388608 /* NodeFlags.Ambient */) !== 0)
+                    return grammarErrorOnNode(g, modifier, 30 /* Diagnostics.X_0_modifier_cannot_be_used_in_an_ambient_context */, 'async');
+                if (node.kind === 170 /* SyntaxKind.Parameter */)
+                    return grammarErrorOnNode(g, modifier, 59 /* Diagnostics.X_0_modifier_cannot_appear_on_a_parameter */, 'async');
+                if ((flags & 64 /* ModifierFlags.Abstract */) !== 0)
+                    return grammarErrorOnNode(g, modifier, 193 /* Diagnostics.X_0_modifier_cannot_be_used_with_1_modifier */, 'async', 'abstract');
+                flags |= 1024 /* ModifierFlags.Async */;
+                lastAsync = modifier;
+                break;
+            case 102 /* SyntaxKind.InKeyword */:
+            case 147 /* SyntaxKind.OutKeyword */: {
+                const inOutFlag = kind === 102 /* SyntaxKind.InKeyword */ ? 8192 /* ModifierFlags.In */ : 16384 /* ModifierFlags.Out */;
+                const inOutText = kind === 102 /* SyntaxKind.InKeyword */ ? 'in' : 'out';
+                if (node.kind !== 169 /* SyntaxKind.TypeParameter */ ||
+                    !(parent.kind === 265 /* SyntaxKind.InterfaceDeclaration */ ||
+                        isClassLike(parent) ||
+                        parent.kind === 266 /* SyntaxKind.TypeAliasDeclaration */ ||
+                        parent.kind === 345 /* SyntaxKind.JSTypeAliasDeclaration */))
+                    return grammarErrorOnNode(g, modifier, 223 /* Diagnostics.X_0_modifier_can_only_appear_on_a_type_parameter_of_a_class_interface_or_type_alias */, inOutText);
+                if ((flags & inOutFlag) !== 0)
+                    return grammarErrorOnNode(g, modifier, 23 /* Diagnostics.X_0_modifier_already_seen */, inOutText);
+                if ((inOutFlag & 8192 /* ModifierFlags.In */) !== 0 && (flags & 16384 /* ModifierFlags.Out */) !== 0)
+                    return grammarErrorOnNode(g, modifier, 22 /* Diagnostics.X_0_modifier_must_precede_1_modifier */, 'in', 'out');
+                flags |= inOutFlag;
+                break;
+            }
+        }
+    }
+    if (node.kind === 177 /* SyntaxKind.Constructor */) {
+        if ((flags & 256 /* ModifierFlags.Static */) !== 0)
+            return grammarErrorOnNode(g, lastStatic, 58 /* Diagnostics.X_0_modifier_cannot_appear_on_a_constructor_declaration */, 'static');
+        if ((flags & 16 /* ModifierFlags.Override */) !== 0)
+            return grammarErrorOnNode(g, lastOverride, 58 /* Diagnostics.X_0_modifier_cannot_appear_on_a_constructor_declaration */, 'override');
+        if ((flags & 1024 /* ModifierFlags.Async */) !== 0)
+            return grammarErrorOnNode(g, lastAsync, 58 /* Diagnostics.X_0_modifier_cannot_appear_on_a_constructor_declaration */, 'async');
+        return false;
+    }
+    if ((node.kind === 273 /* SyntaxKind.ImportDeclaration */ ||
+        node.kind === 346 /* SyntaxKind.JSImportDeclaration */ ||
+        node.kind === 272 /* SyntaxKind.ImportEqualsDeclaration */) &&
+        (flags & 128 /* ModifierFlags.Ambient */) !== 0)
+        return grammarErrorOnNode(g, lastDeclare, 56 /* Diagnostics.A_0_modifier_cannot_be_used_with_an_import_declaration */, 'declare');
+    if (node.kind === 170 /* SyntaxKind.Parameter */ && (flags & 31 /* ModifierFlags.ParameterPropertyModifier */) !== 0) {
+        const parameter = node;
+        if (isBindingPattern(parameter.name))
+            return grammarErrorOnNode(g, node, 143 /* Diagnostics.A_parameter_property_may_not_be_declared_using_a_binding_pattern */);
+        if (parameter.dotDotDotToken !== undefined)
+            return grammarErrorOnNode(g, node, 253 /* Diagnostics.A_parameter_property_cannot_be_declared_using_a_rest_parameter */);
+    }
+    if ((flags & 1024 /* ModifierFlags.Async */) !== 0)
+        return checkGrammarAsyncModifier(g, node, lastAsync);
+    return false;
+}
+function isConstTypeParameterContainer(parent) {
+    switch (parent.kind) {
+        case 185 /* SyntaxKind.FunctionType */:
+        case 186 /* SyntaxKind.ConstructorType */:
+        case 180 /* SyntaxKind.CallSignature */:
+        case 181 /* SyntaxKind.ConstructSignature */:
+        case 174 /* SyntaxKind.MethodSignature */:
+            return true;
+    }
+    return isFunctionLikeDeclarationKind(parent.kind) || isClassLike(parent);
+}
+function reportObviousModifierErrors(g, node, modifiers) {
+    const modifier = findFirstIllegalModifier(node, modifiers);
+    return modifier !== undefined && grammarErrorOnFirstToken(g, modifier, 140 /* Diagnostics.Modifiers_cannot_appear_here */);
+}
+function findFirstModifier(modifiers) {
+    for (const modifier of modifiers.nodes)
+        if (isModifierKind(modifier.kind))
+            return modifier;
+    return undefined;
+}
+function findFirstModifierExcept(modifiers, allowedModifier) {
+    const modifier = findFirstModifier(modifiers);
+    return modifier !== undefined && modifier.kind !== allowedModifier ? modifier : undefined;
+}
+function findFirstIllegalModifier(node, modifiers) {
+    switch (node.kind) {
+        case 178 /* SyntaxKind.GetAccessor */:
+        case 179 /* SyntaxKind.SetAccessor */:
+        case 177 /* SyntaxKind.Constructor */:
+        case 173 /* SyntaxKind.PropertyDeclaration */:
+        case 172 /* SyntaxKind.PropertySignature */:
+        case 175 /* SyntaxKind.MethodDeclaration */:
+        case 174 /* SyntaxKind.MethodSignature */:
+        case 182 /* SyntaxKind.IndexSignature */:
+        case 268 /* SyntaxKind.ModuleDeclaration */:
+        case 273 /* SyntaxKind.ImportDeclaration */:
+        case 346 /* SyntaxKind.JSImportDeclaration */:
+        case 272 /* SyntaxKind.ImportEqualsDeclaration */:
+        case 279 /* SyntaxKind.ExportDeclaration */:
+        case 278 /* SyntaxKind.ExportAssignment */:
+        case 219 /* SyntaxKind.FunctionExpression */:
+        case 220 /* SyntaxKind.ArrowFunction */:
+        case 170 /* SyntaxKind.Parameter */:
+        case 169 /* SyntaxKind.TypeParameter */:
+        case 345 /* SyntaxKind.JSTypeAliasDeclaration */:
+            return undefined;
+        case 176 /* SyntaxKind.ClassStaticBlockDeclaration */:
+        case 303 /* SyntaxKind.PropertyAssignment */:
+        case 304 /* SyntaxKind.ShorthandPropertyAssignment */:
+        case 271 /* SyntaxKind.NamespaceExportDeclaration */:
+        case 283 /* SyntaxKind.MissingDeclaration */:
+            return findFirstModifier(modifiers);
+    }
+    const parent = node.parent;
+    if (parent.kind === 269 /* SyntaxKind.ModuleBlock */ || parent.kind === 307 /* SyntaxKind.SourceFile */)
+        return undefined;
+    switch (node.kind) {
+        case 263 /* SyntaxKind.FunctionDeclaration */:
+            return findFirstModifierExcept(modifiers, 133 /* SyntaxKind.AsyncKeyword */);
+        case 264 /* SyntaxKind.ClassDeclaration */:
+        case 186 /* SyntaxKind.ConstructorType */:
+            return findFirstModifierExcept(modifiers, 127 /* SyntaxKind.AbstractKeyword */);
+        case 244 /* SyntaxKind.VariableStatement */:
+            if ((node.declarationList.flags & 4 /* NodeFlags.Using */) !== 0)
+                return findFirstModifierExcept(modifiers, 134 /* SyntaxKind.AwaitKeyword */);
+            return findFirstModifier(modifiers);
+        case 267 /* SyntaxKind.EnumDeclaration */:
+            return findFirstModifierExcept(modifiers, 86 /* SyntaxKind.ConstKeyword */);
+    }
+    // Class expressions, interfaces and type aliases.
+    return findFirstModifier(modifiers);
+}
+function reportObviousDecoratorErrors(g, node, modifiers) {
+    if (!canHaveIllegalDecorators(node))
+        return false;
+    for (const modifier of modifiers.nodes)
+        if (modifier.kind === 171 /* SyntaxKind.Decorator */)
+            return grammarErrorOnFirstToken(g, modifier, 160 /* Diagnostics.Decorators_are_not_valid_here */);
+    return false;
+}
+function checkGrammarAsyncModifier(g, node, asyncModifier) {
+    switch (node.kind) {
+        case 175 /* SyntaxKind.MethodDeclaration */:
+        case 263 /* SyntaxKind.FunctionDeclaration */:
+        case 219 /* SyntaxKind.FunctionExpression */:
+        case 220 /* SyntaxKind.ArrowFunction */:
+            return false;
+    }
+    return grammarErrorOnNode(g, asyncModifier, 31 /* Diagnostics.X_0_modifier_cannot_be_used_here */, 'async');
+}
+function hasDecorators(node) {
+    const modifiers = getModifiers(node);
+    if (modifiers === undefined)
+        return false;
+    for (const modifier of modifiers.nodes)
+        if (modifier.kind === 171 /* SyntaxKind.Decorator */)
+            return true;
+    return false;
+}
+/** Whether `node` is a valid decorator target. */
+function nodeCanBeDecorated(legacy, node, parent, grandparent) {
+    const name = getName(node);
+    // Legacy decorators don't support private names.
+    if (legacy && name !== undefined && name.kind === 80 /* SyntaxKind.PrivateIdentifier */)
+        return false;
+    switch (node.kind) {
+        case 264 /* SyntaxKind.ClassDeclaration */:
+            return true;
+        case 232 /* SyntaxKind.ClassExpression */:
+            return !legacy;
+        case 173 /* SyntaxKind.PropertyDeclaration */:
+            return (parent !== undefined &&
+                (legacy
+                    ? parent.kind === 264 /* SyntaxKind.ClassDeclaration */
+                    : isClassLike(parent) && !hasSyntacticModifier(node, 64 /* ModifierFlags.Abstract */ | 128 /* ModifierFlags.Ambient */)));
+        case 178 /* SyntaxKind.GetAccessor */:
+        case 179 /* SyntaxKind.SetAccessor */:
+        case 175 /* SyntaxKind.MethodDeclaration */:
+            return (parent !== undefined &&
+                getBody(node) !== undefined &&
+                (legacy ? parent.kind === 264 /* SyntaxKind.ClassDeclaration */ : isClassLike(parent)));
+        case 170 /* SyntaxKind.Parameter */:
+            if (!legacy || parent === undefined || getBody(parent) === undefined)
+                return false;
+            return ((parent.kind === 177 /* SyntaxKind.Constructor */ ||
+                parent.kind === 175 /* SyntaxKind.MethodDeclaration */ ||
+                parent.kind === 179 /* SyntaxKind.SetAccessor */) &&
+                getThisParameter(parent) !== node &&
+                grandparent !== undefined &&
+                grandparent.kind === 264 /* SyntaxKind.ClassDeclaration */);
+    }
+    return false;
+}
+/** The first of the get/set accessor pair `node` belongs to. */
+function getFirstAccessorOfPair(c, node) {
+    const symbol = getSymbolOfDeclaration(c, node);
+    if (symbol === undefined)
+        return node;
+    const otherKind = node.kind === 178 /* SyntaxKind.GetAccessor */ ? 179 /* SyntaxKind.SetAccessor */ : 178 /* SyntaxKind.GetAccessor */;
+    for (const declaration of symbol.declarations)
+        if (declaration.kind === otherKind && declaration.pos < node.pos)
+            return declaration;
+    return node;
+}
+/** The decorator checks of `checkDecorators`. */
+function checkGrammarDecorators(g, node) {
+    if (!canHaveDecorators(node) || !hasDecorators(node))
+        return;
+    if (!nodeCanBeDecorated(g.legacyDecorators, node, node.parent, node.parent.parent))
+        return;
+    for (const modifier of getModifiers(node).nodes)
+        if (modifier.kind === 171 /* SyntaxKind.Decorator */)
+            checkGrammarDecorator(g, modifier);
+}
+function checkGrammarDecorator(g, decorator) {
+    if (g.hasParseErrors)
+        return false;
+    let node = decorator.expression;
+    // `@(expression)`
+    if (node.kind === 218 /* SyntaxKind.ParenthesizedExpression */)
+        return false;
+    let canHaveCallExpression = true;
+    let errorNode;
+    for (;;) {
+        // Non-null assertions and instantiation expressions are allowed.
+        if (node.kind === 234 /* SyntaxKind.ExpressionWithTypeArguments */ || node.kind === 236 /* SyntaxKind.NonNullExpression */) {
+            node = getExpression(node);
+            continue;
+        }
+        // `@member.expression(arguments)`
+        if (node.kind === 214 /* SyntaxKind.CallExpression */) {
+            const call = node;
+            if (!canHaveCallExpression)
+                errorNode = node;
+            // A `?.` token comes first, so it wins over an earlier error node.
+            if (call.questionDotToken !== undefined)
+                errorNode = call.questionDotToken;
+            node = call.expression;
+            canHaveCallExpression = false;
+            continue;
+        }
+        // `@identifier`, `@member.name` and `@member.#name`
+        if (node.kind === 212 /* SyntaxKind.PropertyAccessExpression */) {
+            const access = node;
+            if (access.questionDotToken !== undefined)
+                errorNode = access.questionDotToken;
+            node = access.expression;
+            canHaveCallExpression = false;
+            continue;
+        }
+        if (node.kind !== 79 /* SyntaxKind.Identifier */)
+            errorNode = node;
+        break;
+    }
+    if (errorNode === undefined)
+        return false;
+    const diagnostic = g.c.error(decorator.expression, 412 /* Diagnostics.Expression_must_be_enclosed_in_parentheses_to_be_used_as_a_decorator */);
+    addRelated(diagnostic, errorNode, 413 /* Diagnostics.Invalid_syntax_in_decorator */);
+    return true;
+}
+// ---- Functions and parameters
+function checkGrammarFunctionLikeDeclaration(g, node) {
+    // Short-circuits to prevent cascading errors.
+    return (checkGrammarModifiers(g, node) ||
+        checkGrammarTypeParameterList(g, getTypeParameters(node)) ||
+        checkGrammarParameterList(g, getParameters(node)) ||
+        checkGrammarArrowFunction(g, node) ||
+        (isFunctionLikeDeclarationKind(node.kind) && checkGrammarForUseStrictSimpleParameterList(g, node)));
+}
+function checkGrammarForDisallowedTrailingComma(g, list, message) {
+    return list !== undefined && list.hasTrailingComma() && grammarErrorAtPos(g, list.end - 1, 1, message);
+}
+function checkGrammarTypeParameterList(g, typeParameters) {
+    if (typeParameters === undefined || typeParameters.nodes.length !== 0)
+        return false;
+    const start = typeParameters.pos - 1;
+    const end = skipTrivia(g.file.text, typeParameters.end) + 1;
+    return grammarErrorAtPos(g, start, end - start, 67 /* Diagnostics.Type_parameter_list_cannot_be_empty */);
+}
+function checkGrammarParameterList(g, parameters) {
+    let seenOptionalParameter = false;
+    const count = parameters.nodes.length;
+    for (let i = 0; i < count; i++) {
+        const parameter = parameters.nodes[i];
+        if (parameter.dotDotDotToken !== undefined) {
+            if (i !== count - 1)
+                return grammarErrorOnNode(g, parameter.dotDotDotToken, 10 /* Diagnostics.A_rest_parameter_must_be_last_in_a_parameter_list */);
+            if ((parameter.flags & 8388608 /* NodeFlags.Ambient */) === 0)
+                checkGrammarForDisallowedTrailingComma(g, parameters, 9 /* Diagnostics.A_rest_parameter_or_binding_pattern_may_not_have_a_trailing_comma */);
+            if (parameter.questionToken !== undefined)
+                return grammarErrorOnNode(g, parameter.questionToken, 34 /* Diagnostics.A_rest_parameter_cannot_be_optional */);
+            if (parameter.initializer !== undefined)
+                return grammarErrorOnNode(g, parameter.name, 35 /* Diagnostics.A_rest_parameter_cannot_have_an_initializer */);
+        }
+        else if (parameter.questionToken !== undefined) {
+            seenOptionalParameter = true;
+            // A reparsed `?` comes from a bracketed `@param` name.
+            if ((parameter.questionToken.flags & 8 /* NodeFlags.Reparsed */) === 0 && parameter.initializer !== undefined)
+                return grammarErrorOnNode(g, parameter.name, 11 /* Diagnostics.Parameter_cannot_have_question_mark_and_initializer */);
+        }
+        else if (seenOptionalParameter && parameter.initializer === undefined) {
+            return grammarErrorOnNode(g, parameter.name, 12 /* Diagnostics.A_required_parameter_cannot_follow_an_optional_parameter */);
+        }
+    }
+    return false;
+}
+function checkGrammarForUseStrictSimpleParameterList(g, node) {
+    if (g.c.languageVersion < ScriptTarget.ES2016)
+        return false;
+    const body = getBody(node);
+    if (body === undefined || body.kind !== 242 /* SyntaxKind.Block */)
+        return false;
+    const useStrictDirective = findUseStrictPrologue(g.file, getStatements(body).nodes);
+    if (useStrictDirective === undefined)
+        return false;
+    const nonSimpleParameters = [];
+    for (const parameter of getParameters(node).nodes) {
+        const p = parameter;
+        if (p.initializer !== undefined || isBindingPattern(p.name) || p.dotDotDotToken !== undefined)
+            nonSimpleParameters.push(parameter);
+    }
+    if (nonSimpleParameters.length === 0)
+        return false;
+    for (const parameter of nonSimpleParameters) {
+        const diagnostic = g.c.error(parameter, 280 /* Diagnostics.This_parameter_is_not_allowed_with_use_strict_directive */);
+        addRelated(diagnostic, useStrictDirective, 283 /* Diagnostics.X_use_strict_directive_used_here */);
+    }
+    const diagnostic = g.c.error(useStrictDirective, 281 /* Diagnostics.X_use_strict_directive_cannot_be_used_with_non_simple_parameter_list */);
+    for (let i = 0; i < nonSimpleParameters.length; i++)
+        addRelated(diagnostic, nonSimpleParameters[i], i === 0 ? 282 /* Diagnostics.Non_simple_parameter_declared_here */ : 1357 /* Diagnostics.X_and_here */);
+    return true;
+}
+function checkGrammarArrowFunction(g, node) {
+    if (node.kind !== 220 /* SyntaxKind.ArrowFunction */)
+        return false;
+    const arrow = node;
+    const typeParameters = arrow.typeParameters;
+    if (typeParameters !== undefined) {
+        const nodes = typeParameters.nodes;
+        const hasConstraint = nodes.length > 0 && nodes[0].constraint !== undefined;
+        if (!(nodes.length > 1 || typeParameters.hasTrailingComma() || hasConstraint) &&
+            fileExtensionIsOneOf(g.file.fileName, ['.mts', '.cts']))
+            grammarErrorOnNode(g, nodes[0], 1731 /* Diagnostics.This_syntax_is_reserved_in_files_with_the_mts_or_cts_extension_Add_a_trailing_comma_or_explicit_constraint */);
+    }
+    const arrowToken = arrow.equalsGreaterThanToken;
+    if (arrowToken === undefined)
+        return false;
+    const lineStarts = g.file.lineStarts();
+    return (computeLineOfPosition(lineStarts, arrowToken.pos) !== computeLineOfPosition(lineStarts, arrowToken.end) &&
+        grammarErrorOnNode(g, arrowToken, 156 /* Diagnostics.Line_terminator_not_permitted_before_arrow */));
+}
+function checkGrammarForGenerator(g, node) {
+    const asteriskToken = getAsteriskToken(node);
+    if (asteriskToken === undefined)
+        return false;
+    if ((node.flags & 8388608 /* NodeFlags.Ambient */) !== 0)
+        return grammarErrorOnNode(g, asteriskToken, 171 /* Diagnostics.Generators_are_not_allowed_in_an_ambient_context */);
+    if (getBody(node) === undefined)
+        return grammarErrorOnNode(g, asteriskToken, 172 /* Diagnostics.An_overload_signature_cannot_be_declared_as_a_generator */);
+    return false;
+}
+function isThisParameter(node) {
+    if (node.kind !== 170 /* SyntaxKind.Parameter */)
+        return false;
+    const name = node.name;
+    return name instanceof Identifier && name.text === 'this';
+}
+function getThisParameter(signature) {
+    const parameters = getParameters(signature);
+    if (parameters === undefined || parameters.nodes.length === 0)
+        return undefined;
+    const first = parameters.nodes[0];
+    return isThisParameter(first) ? first : undefined;
+}
+function isBindingPattern(node) {
+    return (node !== undefined &&
+        (node.kind === 207 /* SyntaxKind.ObjectBindingPattern */ || node.kind === 208 /* SyntaxKind.ArrayBindingPattern */));
+}
+// ---- Signatures and members
+function checkGrammarIndexSignatureParameters(g, node) {
+    const parameters = node.parameters.nodes;
+    if (parameters.length === 0)
+        return grammarErrorOnNode(g, node, 65 /* Diagnostics.An_index_signature_must_have_exactly_one_parameter */);
+    const parameter = parameters[0];
+    if (parameters.length !== 1)
+        return grammarErrorOnNode(g, parameter.name, 65 /* Diagnostics.An_index_signature_must_have_exactly_one_parameter */);
+    checkGrammarForDisallowedTrailingComma(g, node.parameters, 20 /* Diagnostics.An_index_signature_cannot_have_a_trailing_comma */);
+    if (parameter.dotDotDotToken !== undefined)
+        return grammarErrorOnNode(g, parameter.dotDotDotToken, 13 /* Diagnostics.An_index_signature_cannot_have_a_rest_parameter */);
+    if (parameter.modifiers !== undefined)
+        return grammarErrorOnNode(g, parameter.name, 14 /* Diagnostics.An_index_signature_parameter_cannot_have_an_accessibility_modifier */);
+    if (parameter.questionToken !== undefined)
+        return grammarErrorOnNode(g, parameter.questionToken, 15 /* Diagnostics.An_index_signature_parameter_cannot_have_a_question_mark */);
+    if (parameter.initializer !== undefined)
+        return grammarErrorOnNode(g, parameter.name, 16 /* Diagnostics.An_index_signature_parameter_cannot_have_an_initializer */);
+    if (parameter.type === undefined)
+        return grammarErrorOnNode(g, parameter.name, 18 /* Diagnostics.An_index_signature_parameter_must_have_a_type_annotation */);
+    const t = getTypeFromTypeNode(g.c, parameter.type);
+    if (someTypeHasFlags(t, 19456 /* TypeFlags.StringOrNumberLiteralOrUnique */) || isGenericType(g.c, t))
+        return grammarErrorOnNode(g, parameter.name, 272 /* Diagnostics.An_index_signature_parameter_type_cannot_be_a_literal_type_or_generic_type_Consider_using_a_mapped_object_type_instead */);
+    if (!everyTypeIsValidIndexKey(g.c, t))
+        return grammarErrorOnNode(g, parameter.name, 217 /* Diagnostics.An_index_signature_parameter_type_must_be_string_number_symbol_or_a_template_literal_type */);
+    if (node.type === undefined)
+        return grammarErrorOnNode(g, node, 17 /* Diagnostics.An_index_signature_must_have_a_type_annotation */);
+    return false;
+}
+function someTypeHasFlags(t, flags) {
+    if ((t.flags & 134217728 /* TypeFlags.Union */) === 0)
+        return (t.flags & flags) !== 0;
+    for (const member of t.types)
+        if ((member.flags & flags) !== 0)
+            return true;
+    return false;
+}
+function everyTypeIsValidIndexKey(c, t) {
+    if ((t.flags & 134217728 /* TypeFlags.Union */) === 0)
+        return isValidIndexKeyType(c, t);
+    for (const member of t.types)
+        if (!isValidIndexKeyType(c, member))
+            return false;
+    return true;
+}
+function checkGrammarTypeArguments(g, typeArguments) {
+    if (checkGrammarForDisallowedTrailingComma(g, typeArguments, 5 /* Diagnostics.Trailing_comma_not_allowed */))
+        return true;
+    if (typeArguments === undefined || typeArguments.nodes.length !== 0)
+        return false;
+    const start = typeArguments.pos - 1;
+    const end = skipTrivia(g.file.text, typeArguments.end) + 1;
+    return grammarErrorAtPos(g, start, end - start, 68 /* Diagnostics.Type_argument_list_cannot_be_empty */);
+}
+function checkGrammarExpressionWithTypeArguments(g, node) {
+    const typeArguments = getTypeArguments(node);
+    if (node.kind === 234 /* SyntaxKind.ExpressionWithTypeArguments */ &&
+        node.expression.kind === 101 /* SyntaxKind.ImportKeyword */ &&
+        typeArguments !== undefined)
+        return grammarErrorOnNode(g, node, 262 /* Diagnostics.This_use_of_import_is_invalid_import_calls_can_be_written_but_they_must_have_parentheses_and_cannot_have_type_arguments */);
+    return checkGrammarTypeArguments(g, typeArguments);
+}
+function checkGrammarHeritageClause(g, clause) {
+    const types = clause.types;
+    if (checkGrammarForDisallowedTrailingComma(g, types, 5 /* Diagnostics.Trailing_comma_not_allowed */))
+        return true;
+    if (types.nodes.length === 0)
+        return grammarErrorAtPos(g, types.pos, 0, 66 /* Diagnostics.X_0_list_cannot_be_empty */, tokenToString(clause.token));
+    for (const type of types.nodes)
+        if (checkGrammarExpressionWithTypeArguments(g, type))
+            return true;
+    return false;
+}
+function checkGrammarClassDeclaration(g, node) {
+    const modifiers = getModifiers(node);
+    if (g.legacyDecorators && modifiers !== undefined) {
+        let firstDecorator;
+        for (const modifier of modifiers.nodes)
+            if (modifier.kind === 171 /* SyntaxKind.Decorator */) {
+                firstDecorator = modifier;
+                break;
+            }
+        if (firstDecorator !== undefined)
+            for (const member of getMembers(node).nodes)
+                if (hasSyntacticModifier(member, 256 /* ModifierFlags.Static */) && isPrivateIdentifierClassElementDeclaration(member)) {
+                    grammarErrorOnNode(g, firstDecorator, 1853 /* Diagnostics.Class_decorators_can_t_be_used_with_static_private_identifier_Consider_removing_the_experimental_decorator */);
+                    break;
+                }
+    }
+    if (getName(node) === undefined && !hasSyntacticModifier(node, 2048 /* ModifierFlags.Default */))
+        grammarErrorOnFirstToken(g, node, 164 /* Diagnostics.A_class_declaration_without_the_default_modifier_must_have_a_name */);
+    checkGrammarClassLikeDeclaration(g, node);
+}
+function checkGrammarClassLikeDeclaration(g, node) {
+    if (!checkGrammarClassDeclarationHeritageClauses(g, node))
+        checkGrammarTypeParameterList(g, getTypeParameters(node));
+    checkGrammarDecorators(g, node);
+    // `implements` clause elements are checked again as type references.
+    const clauses = getHeritageClauses(node);
+    if (clauses !== undefined)
+        for (const clause of clauses.nodes)
+            if (clause.token === 118 /* SyntaxKind.ImplementsKeyword */)
+                for (const type of clause.types.nodes)
+                    checkGrammarTypeArguments(g, getTypeArguments(type));
+}
+function checkGrammarClassDeclarationHeritageClauses(g, node) {
+    let seenExtendsClause = false;
+    let seenImplementsClause = false;
+    const clauses = getHeritageClauses(node);
+    if (checkGrammarModifiers(g, node) || clauses === undefined)
+        return false;
+    for (const clauseNode of clauses.nodes) {
+        const clause = clauseNode;
+        if (clause.token === 95 /* SyntaxKind.ExtendsKeyword */) {
+            if (seenExtendsClause)
+                return grammarErrorOnFirstToken(g, clause, 128 /* Diagnostics.X_extends_clause_already_seen */);
+            if (seenImplementsClause)
+                return grammarErrorOnFirstToken(g, clause, 129 /* Diagnostics.X_extends_clause_must_precede_implements_clause */);
+            if (clause.types.nodes.length > 1)
+                return grammarErrorOnFirstToken(g, clause.types.nodes[1], 130 /* Diagnostics.Classes_can_only_extend_a_single_class */);
+            if (clause.types.nodes.length > 0) {
+                const mismatch = findMismatchedAugmentsTag(node, clause.types.nodes[0]);
+                if (mismatch !== undefined)
+                    return grammarErrorOnNode(g, mismatch.name, 1752 /* Diagnostics.JSDoc_0_1_does_not_match_the_extends_2_clause */, mismatch.tagName, mismatch.className, mismatch.extendsName);
+            }
+            seenExtendsClause = true;
+        }
+        else {
+            if (seenImplementsClause)
+                return grammarErrorOnFirstToken(g, clause, 131 /* Diagnostics.X_implements_clause_already_seen */);
+            seenImplementsClause = true;
+        }
+        checkGrammarHeritageClause(g, clause);
+    }
+    return false;
+}
+function checkGrammarInterfaceDeclaration(g, node) {
+    const clauses = getHeritageClauses(node);
+    if (!checkGrammarModifiers(g, node) && clauses !== undefined) {
+        let seenExtendsClause = false;
+        for (const clauseNode of clauses.nodes) {
+            const clause = clauseNode;
+            if (clause.token === 95 /* SyntaxKind.ExtendsKeyword */) {
+                if (seenExtendsClause) {
+                    grammarErrorOnFirstToken(g, clause, 128 /* Diagnostics.X_extends_clause_already_seen */);
+                    break;
+                }
+                seenExtendsClause = true;
+            }
+            else {
+                grammarErrorOnFirstToken(g, clause, 132 /* Diagnostics.Interface_declaration_cannot_have_implements_clause */);
+                break;
+            }
+            checkGrammarHeritageClause(g, clause);
+        }
+    }
+    if (!containerAllowsBlockScopedVariable(node.parent))
+        grammarErrorOnNode(g, node, 116 /* Diagnostics.X_0_declarations_can_only_be_declared_inside_a_block */, 'interface');
+    // `extends` clause elements are checked again as type references.
+    if (clauses !== undefined)
+        for (const clause of clauses.nodes)
+            if (clause.token === 95 /* SyntaxKind.ExtendsKeyword */)
+                for (const type of clause.types.nodes)
+                    checkGrammarTypeArguments(g, getTypeArguments(type));
+}
+function checkGrammarComputedPropertyName(g, node) {
+    if (node.kind !== 168 /* SyntaxKind.ComputedPropertyName */)
+        return false;
+    const expression = node.expression;
+    return (expression.kind === 227 /* SyntaxKind.BinaryExpression */ &&
+        expression.operatorToken.kind === 27 /* SyntaxKind.CommaToken */ &&
+        grammarErrorOnNode(g, expression, 127 /* Diagnostics.A_comma_expression_is_not_allowed_in_a_computed_property_name */));
+}
+function checkGrammarForInvalidQuestionMark(g, postfixToken, message) {
+    return (postfixToken !== undefined &&
+        postfixToken.kind === 57 /* SyntaxKind.QuestionToken */ &&
+        grammarErrorOnNode(g, postfixToken, message));
+}
+function checkGrammarForInvalidExclamationToken(g, postfixToken, message) {
+    return (postfixToken !== undefined &&
+        postfixToken.kind === 53 /* SyntaxKind.ExclamationToken */ &&
+        grammarErrorOnNode(g, postfixToken, message));
+}
+/** Whether a name is dynamic and can't be late bound: its type isn't a literal or unique symbol. */
+function isNonBindableDynamicName(c, node) {
+    if (!isDynamicName(node))
+        return false;
+    let expression;
+    if (node.kind === 168 /* SyntaxKind.ComputedPropertyName */)
+        expression = getExpression(node);
+    else if (node instanceof ElementAccessExpression)
+        expression = node.argumentExpression;
+    if (expression === undefined || !isEntityNameExpression(expression, false))
+        return true;
+    const t = node.kind === 168 /* SyntaxKind.ComputedPropertyName */
+        ? checkComputedPropertyName(c, node)
+        : checkExpressionCached(c, expression);
+    return !isTypeUsableAsPropertyName(t);
+}
+function checkGrammarForInvalidDynamicName(g, node, message) {
+    if (!isNonBindableDynamicName(g.c, node))
+        return false;
+    const expression = node instanceof ElementAccessExpression ? skipParentheses(node.argumentExpression) : getExpression(node);
+    return !isEntityNameExpression(expression, false) && grammarErrorOnNode(g, node, message);
+}
+function checkGrammarMethodDeclaration(g, node) {
+    if (node.parent.kind === 211 /* SyntaxKind.ObjectLiteralExpression */) {
+        // `checkObjectLiteralMethod` checks the method, then checks it again as a function expression.
+        checkGrammarMethod(g, node);
+        checkGrammarFunctionLikeDeclaration(g, node);
+        return;
+    }
+    const name = getName(node);
+    if (!checkGrammarMethod(g, node)) {
+        checkGrammarComputedPropertyName(g, name);
+        if (getAsteriskToken(node) !== undefined && name instanceof Identifier && name.text === 'constructor')
+            g.c.error(name, 302 /* Diagnostics.Class_constructor_may_not_be_a_generator */);
+    }
+    checkGrammarDecorators(g, node);
+    if (name.kind === 80 /* SyntaxKind.PrivateIdentifier */ && getContainingClass(node) === undefined)
+        g.c.error(node, 1838 /* Diagnostics.Private_identifiers_are_not_allowed_outside_class_bodies */);
+}
+function checkGrammarMethod(g, node) {
+    if (checkGrammarFunctionLikeDeclaration(g, node))
+        return true;
+    const parent = node.parent;
+    if (node.kind === 175 /* SyntaxKind.MethodDeclaration */) {
+        if (parent.kind === 211 /* SyntaxKind.ObjectLiteralExpression */) {
+            // Only `async` is allowed on object literal methods.
+            const modifiers = getModifiers(node);
+            if (modifiers !== undefined &&
+                !(modifiers.nodes.length === 1 && modifiers.nodes[0].kind === 133 /* SyntaxKind.AsyncKeyword */))
+                return grammarErrorOnFirstToken(g, node, 140 /* Diagnostics.Modifiers_cannot_appear_here */);
+            const postfixToken = getPostfixToken(node);
+            if (checkGrammarForInvalidQuestionMark(g, postfixToken, 119 /* Diagnostics.An_object_member_cannot_be_declared_optional */))
+                return true;
+            if (checkGrammarForInvalidExclamationToken(g, postfixToken, 205 /* Diagnostics.A_definite_assignment_assertion_is_not_permitted_in_this_context */))
+                return true;
+            if (getBody(node) === undefined)
+                return grammarErrorAtPos(g, node.end - 1, 1, 2 /* Diagnostics.X_0_expected */, '{');
+        }
+        if (checkGrammarForGenerator(g, node))
+            return true;
+    }
+    const name = getName(node);
+    if (isClassLike(parent)) {
+        // Computed names are disallowed in ambient contexts for properties and accessors too, but
+        // those report other errors first.
+        if ((node.flags & 8388608 /* NodeFlags.Ambient */) !== 0)
+            return checkGrammarForInvalidDynamicName(g, name, 122 /* Diagnostics.A_computed_property_name_in_an_ambient_context_must_refer_to_an_expression_whose_type_is_a_literal_type_or_a_unique_symbol_type */);
+        if (node.kind === 175 /* SyntaxKind.MethodDeclaration */ && getBody(node) === undefined)
+            return checkGrammarForInvalidDynamicName(g, name, 124 /* Diagnostics.A_computed_property_name_in_a_method_overload_must_refer_to_an_expression_whose_type_is_a_literal_type_or_a_unique_symbol_type */);
+    }
+    else if (parent.kind === 265 /* SyntaxKind.InterfaceDeclaration */) {
+        return checkGrammarForInvalidDynamicName(g, name, 125 /* Diagnostics.A_computed_property_name_in_an_interface_must_refer_to_an_expression_whose_type_is_a_literal_type_or_a_unique_symbol_type */);
+    }
+    else if (parent.kind === 188 /* SyntaxKind.TypeLiteral */) {
+        return checkGrammarForInvalidDynamicName(g, name, 126 /* Diagnostics.A_computed_property_name_in_a_type_literal_must_refer_to_an_expression_whose_type_is_a_literal_type_or_a_unique_symbol_type */);
+    }
+    return false;
+}
+function checkGrammarConstructorTypeParameters(g, node) {
+    const range = node.typeParameters;
+    if (range === undefined)
+        return false;
+    const pos = range.pos === range.end ? range.pos : skipTrivia(g.file.text, range.pos);
+    return grammarErrorAtPos(g, pos, range.end - pos, 61 /* Diagnostics.Type_parameters_cannot_appear_on_a_constructor_declaration */);
+}
+function checkGrammarAccessorDeclaration(g, node) {
+    const name = getName(node);
+    if (!checkGrammarFunctionLikeDeclaration(g, node) && !checkGrammarAccessor(g, node))
+        checkGrammarComputedPropertyName(g, name);
+    checkGrammarDecorators(g, node);
+}
+function checkGrammarAccessor(g, accessor) {
+    const body = getBody(accessor);
+    const parent = accessor.parent;
+    const inTypeMember = parent.kind === 188 /* SyntaxKind.TypeLiteral */ || parent.kind === 265 /* SyntaxKind.InterfaceDeclaration */;
+    const isAbstract = hasSyntacticModifier(accessor, 64 /* ModifierFlags.Abstract */);
+    if ((accessor.flags & 8388608 /* NodeFlags.Ambient */) === 0 && !inTypeMember && body === undefined && !isAbstract)
+        return grammarErrorAtPos(g, accessor.end - 1, 1, 2 /* Diagnostics.X_0_expected */, '{');
+    if (body !== undefined) {
+        if (isAbstract)
+            return grammarErrorOnNode(g, accessor, 254 /* Diagnostics.An_abstract_accessor_cannot_have_an_implementation */);
+        if (inTypeMember)
+            return grammarErrorOnNode(g, body, 139 /* Diagnostics.An_implementation_cannot_be_declared_in_ambient_contexts */);
+    }
+    const name = getName(accessor);
+    if (getTypeParameters(accessor) !== undefined)
+        return grammarErrorOnNode(g, name, 63 /* Diagnostics.An_accessor_cannot_have_type_parameters */);
+    const parameters = getParameters(accessor).nodes;
+    const isGetter = accessor.kind === 178 /* SyntaxKind.GetAccessor */;
+    // A `this` parameter only counts with the right number of other parameters.
+    const hasThisParameter = parameters.length === (isGetter ? 1 : 2) && isThisParameter(parameters[0]);
+    if (!hasThisParameter && parameters.length !== (isGetter ? 0 : 1))
+        return grammarErrorOnNode(g, name, isGetter
+            ? 40 /* Diagnostics.A_get_accessor_cannot_have_parameters */
+            : 36 /* Diagnostics.A_set_accessor_must_have_exactly_one_parameter */);
+    if (!isGetter) {
+        if (getType(accessor) !== undefined)
+            return grammarErrorOnNode(g, name, 64 /* Diagnostics.A_set_accessor_cannot_have_a_return_type_annotation */);
+        const parameter = parameters[hasThisParameter ? 1 : 0];
+        if (parameter.dotDotDotToken !== undefined)
+            return grammarErrorOnNode(g, parameter.dotDotDotToken, 39 /* Diagnostics.A_set_accessor_cannot_have_rest_parameter */);
+        if (parameter.questionToken !== undefined)
+            return grammarErrorOnNode(g, parameter.questionToken, 37 /* Diagnostics.A_set_accessor_cannot_have_an_optional_parameter */);
+        if (parameter.initializer !== undefined)
+            return grammarErrorOnNode(g, name, 38 /* Diagnostics.A_set_accessor_parameter_cannot_have_an_initializer */);
+    }
+    return false;
+}
+function checkGrammarPropertyDeclaration(g, node) {
+    if (!checkGrammarModifiers(g, node) && !checkGrammarProperty(g, node))
+        checkGrammarComputedPropertyName(g, getName(node));
+}
+function checkGrammarProperty(g, node) {
+    const name = getName(node);
+    const parent = node.parent;
+    if (name.kind === 168 /* SyntaxKind.ComputedPropertyName */) {
+        const expression = name.expression;
+        if (expression.kind === 227 /* SyntaxKind.BinaryExpression */ &&
+            expression.operatorToken.kind === 102 /* SyntaxKind.InKeyword */)
+            return grammarErrorOnNode(g, getMembers(parent).nodes[0], 1732 /* Diagnostics.A_mapped_type_may_not_declare_properties_or_methods */);
+    }
+    if (isClassLike(parent)) {
+        if (name instanceof StringLiteral && name.text === 'constructor')
+            return grammarErrorOnNode(g, name, 1829 /* Diagnostics.Classes_may_not_have_a_field_named_constructor */);
+        if (checkGrammarForInvalidDynamicName(g, name, 123 /* Diagnostics.A_computed_property_name_in_a_class_property_declaration_must_have_a_simple_literal_type_or_a_unique_symbol_type */))
+            return true;
+        if (isAutoAccessorPropertyDeclaration(node) &&
+            checkGrammarForInvalidQuestionMark(g, getPostfixToken(node), 225 /* Diagnostics.An_accessor_property_cannot_be_declared_optional */))
+            return true;
+    }
+    else if (parent.kind === 265 /* SyntaxKind.InterfaceDeclaration */) {
+        if (checkGrammarForInvalidDynamicName(g, name, 125 /* Diagnostics.A_computed_property_name_in_an_interface_must_refer_to_an_expression_whose_type_is_a_literal_type_or_a_unique_symbol_type */))
+            return true;
+        const initializer = getInitializer(node);
+        if (initializer !== undefined)
+            return grammarErrorOnNode(g, initializer, 196 /* Diagnostics.An_interface_property_cannot_have_an_initializer */);
+    }
+    else if (parent.kind === 188 /* SyntaxKind.TypeLiteral */) {
+        if (checkGrammarForInvalidDynamicName(g, name, 126 /* Diagnostics.A_computed_property_name_in_a_type_literal_must_refer_to_an_expression_whose_type_is_a_literal_type_or_a_unique_symbol_type */))
+            return true;
+        const initializer = getInitializer(node);
+        if (initializer !== undefined)
+            return grammarErrorOnNode(g, initializer, 197 /* Diagnostics.A_type_literal_property_cannot_have_an_initializer */);
+    }
+    if ((node.flags & 8388608 /* NodeFlags.Ambient */) !== 0)
+        checkAmbientInitializer(g, node);
+    if (node.kind === 173 /* SyntaxKind.PropertyDeclaration */) {
+        const property = node;
+        const postfixToken = property.postfixToken;
+        if (postfixToken !== undefined && postfixToken.kind === 53 /* SyntaxKind.ExclamationToken */) {
+            if (property.initializer !== undefined)
+                return grammarErrorOnNode(g, postfixToken, 212 /* Diagnostics.Declarations_with_initializers_cannot_also_have_definite_assignment_assertions */);
+            if (property.type === undefined)
+                return grammarErrorOnNode(g, postfixToken, 213 /* Diagnostics.Declarations_with_definite_assignment_assertions_must_also_have_type_annotations */);
+            if (!isClassLike(parent) ||
+                (node.flags & 8388608 /* NodeFlags.Ambient */) !== 0 ||
+                isStatic(node) ||
+                hasSyntacticModifier(node, 64 /* ModifierFlags.Abstract */))
+                return grammarErrorOnNode(g, postfixToken, 205 /* Diagnostics.A_definite_assignment_assertion_is_not_permitted_in_this_context */);
+        }
+    }
+    return false;
+}
+function checkAmbientInitializer(g, node) {
+    const initializer = getInitializer(node);
+    if (initializer === undefined)
+        return false;
+    const isInvalidInitializer = !(isInitializerStringOrNumberLiteralExpression(initializer) ||
+        isInitializerSimpleLiteralEnumReference(g.c, initializer) ||
+        initializer.kind === 111 /* SyntaxKind.TrueKeyword */ ||
+        initializer.kind === 96 /* SyntaxKind.FalseKeyword */ ||
+        isInitializerBigIntLiteralExpression(initializer));
+    const isConstOrReadonly = isDeclarationReadonly(node) || (node.kind === 261 /* SyntaxKind.VariableDeclaration */ && isVarConstLike(node));
+    if (!isConstOrReadonly || getType(node) !== undefined)
+        return grammarErrorOnNode(g, initializer, 29 /* Diagnostics.Initializers_are_not_allowed_in_ambient_contexts */);
+    if (isInvalidInitializer)
+        return grammarErrorOnNode(g, initializer, 204 /* Diagnostics.A_const_initializer_in_an_ambient_context_must_be_a_string_or_numeric_literal_or_literal_enum_reference */);
+    return false;
+}
+function isDeclarationReadonly(node) {
+    return ((getCombinedModifierFlags(node) & 8 /* ModifierFlags.Readonly */) !== 0 &&
+        !(node.kind === 170 /* SyntaxKind.Parameter */ && node.parent.kind === 177 /* SyntaxKind.Constructor */));
+}
+function isVarConstLike(node) {
+    const blockScopeKind = getCombinedNodeFlags(node) & 7 /* NodeFlags.BlockScoped */;
+    return (blockScopeKind === 2 /* NodeFlags.Const */ || blockScopeKind === 4 /* NodeFlags.Using */ || blockScopeKind === 6 /* NodeFlags.AwaitUsing */);
+}
+function isInitializerStringOrNumberLiteralExpression(expression) {
+    switch (expression.kind) {
+        case 10 /* SyntaxKind.StringLiteral */:
+        case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */:
+        case 8 /* SyntaxKind.NumericLiteral */:
+            return true;
+        case 225 /* SyntaxKind.PrefixUnaryExpression */: {
+            const unary = expression;
+            return unary.operator === 40 /* SyntaxKind.MinusToken */ && unary.operand.kind === 8 /* SyntaxKind.NumericLiteral */;
+        }
+    }
+    return false;
+}
+function isInitializerBigIntLiteralExpression(expression) {
+    if (expression.kind === 9 /* SyntaxKind.BigIntLiteral */)
+        return true;
+    if (expression.kind !== 225 /* SyntaxKind.PrefixUnaryExpression */)
+        return false;
+    const unary = expression;
+    return unary.operator === 40 /* SyntaxKind.MinusToken */ && unary.operand.kind === 9 /* SyntaxKind.BigIntLiteral */;
+}
+function isInitializerSimpleLiteralEnumReference(c, expression) {
+    if (expression.kind === 212 /* SyntaxKind.PropertyAccessExpression */)
+        return (checkExpressionCached(c, expression).flags & 98304 /* TypeFlags.EnumLike */) !== 0;
+    if (expression instanceof ElementAccessExpression)
+        return (isInitializerStringOrNumberLiteralExpression(expression.argumentExpression) &&
+            isEntityNameExpression(expression.expression, false) &&
+            (checkExpressionCached(c, expression).flags & 98304 /* TypeFlags.EnumLike */) !== 0);
+    return false;
+}
+// ---- Statements
+function checkGrammarStatementInAmbientContext(g, node) {
+    if ((node.flags & 8388608 /* NodeFlags.Ambient */) === 0)
+        return false;
+    const parent = node.parent;
+    const id = getNodeId(node);
+    if (!g.reportedAmbientStatements.has(id) && (isFunctionLike(parent) || isAccessor(parent))) {
+        const reported = grammarErrorOnFirstToken(g, node, 139 /* Diagnostics.An_implementation_cannot_be_declared_in_ambient_contexts */);
+        if (reported)
+            g.reportedAmbientStatements.add(id);
+        return reported;
+    }
+    // Report once per block; statements nested in other statements are covered by their parent.
+    if (parent.kind === 242 /* SyntaxKind.Block */ ||
+        parent.kind === 269 /* SyntaxKind.ModuleBlock */ ||
+        parent.kind === 307 /* SyntaxKind.SourceFile */) {
+        const parentId = getNodeId(parent);
+        if (!g.reportedAmbientStatements.has(parentId)) {
+            const reported = grammarErrorOnFirstToken(g, node, 27 /* Diagnostics.Statements_are_not_allowed_in_ambient_contexts */);
+            if (reported)
+                g.reportedAmbientStatements.add(parentId);
+            return reported;
+        }
+    }
+    return false;
+}
+function isAccessor(node) {
+    return node.kind === 178 /* SyntaxKind.GetAccessor */ || node.kind === 179 /* SyntaxKind.SetAccessor */;
+}
+function checkGrammarVariableStatement(g, node) {
+    if (!checkGrammarModifiers(g, node) && !checkGrammarVariableDeclarationList(g, node.declarationList))
+        checkGrammarForDisallowedBlockScopedVariableStatement(g, node);
+}
+function checkGrammarForDisallowedBlockScopedVariableStatement(g, node) {
+    if (containerAllowsBlockScopedVariable(node.parent))
+        return;
+    const blockScopeKind = getCombinedNodeFlags(node.declarationList) & 7 /* NodeFlags.BlockScoped */;
+    if (blockScopeKind === 0)
+        return;
+    let keyword;
+    if (blockScopeKind === 1 /* NodeFlags.Let */)
+        keyword = 'let';
+    else if (blockScopeKind === 2 /* NodeFlags.Const */)
+        keyword = 'const';
+    else if (blockScopeKind === 4 /* NodeFlags.Using */)
+        keyword = 'using';
+    else
+        keyword = 'await using';
+    g.c.error(node, 116 /* Diagnostics.X_0_declarations_can_only_be_declared_inside_a_block */, keyword);
+}
+function containerAllowsBlockScopedVariable(parent) {
+    switch (parent.kind) {
+        case 246 /* SyntaxKind.IfStatement */:
+        case 247 /* SyntaxKind.DoStatement */:
+        case 248 /* SyntaxKind.WhileStatement */:
+        case 255 /* SyntaxKind.WithStatement */:
+        case 249 /* SyntaxKind.ForStatement */:
+        case 250 /* SyntaxKind.ForInStatement */:
+        case 251 /* SyntaxKind.ForOfStatement */:
+            return false;
+        case 257 /* SyntaxKind.LabeledStatement */:
+            return containerAllowsBlockScopedVariable(parent.parent);
+    }
+    return true;
+}
+function checkGrammarVariableDeclarationList(g, list) {
+    const declarations = list.declarations;
+    if (checkGrammarForDisallowedTrailingComma(g, declarations, 5 /* Diagnostics.Trailing_comma_not_allowed */))
+        return true;
+    if (declarations.nodes.length === 0)
+        return grammarErrorAtPos(g, declarations.pos, declarations.end - declarations.pos, 90 /* Diagnostics.Variable_declaration_list_cannot_be_empty */);
+    const blockScopeFlags = list.flags & 7 /* NodeFlags.BlockScoped */;
+    const parent = list.parent;
+    if (blockScopeFlags === 4 /* NodeFlags.Using */ || blockScopeFlags === 6 /* NodeFlags.AwaitUsing */) {
+        const isUsing = blockScopeFlags === 4 /* NodeFlags.Using */;
+        if (parent.kind === 250 /* SyntaxKind.ForInStatement */)
+            return grammarErrorOnNode(g, list, isUsing
+                ? 408 /* Diagnostics.The_left_hand_side_of_a_for_in_statement_cannot_be_a_using_declaration */
+                : 409 /* Diagnostics.The_left_hand_side_of_a_for_in_statement_cannot_be_an_await_using_declaration */);
+        if ((list.flags & 8388608 /* NodeFlags.Ambient */) !== 0)
+            return grammarErrorOnNode(g, list, isUsing
+                ? 460 /* Diagnostics.X_using_declarations_are_not_allowed_in_ambient_contexts */
+                : 461 /* Diagnostics.X_await_using_declarations_are_not_allowed_in_ambient_contexts */);
+        if (parent.kind === 244 /* SyntaxKind.VariableStatement */ &&
+            (parent.parent.kind === 297 /* SyntaxKind.CaseClause */ || parent.parent.kind === 298 /* SyntaxKind.DefaultClause */))
+            return grammarErrorOnNode(g, list, isUsing
+                ? 462 /* Diagnostics.X_using_declarations_are_not_allowed_in_case_or_default_clauses_unless_contained_within_a_block */
+                : 463 /* Diagnostics.X_await_using_declarations_are_not_allowed_in_case_or_default_clauses_unless_contained_within_a_block */);
+    }
+    if (blockScopeFlags === 6 /* NodeFlags.AwaitUsing */)
+        return checkGrammarAwaitOrAwaitUsing(g, list);
+    return false;
+}
+function checkGrammarVariableDeclaration(g, node) {
+    const nodeFlags = getCombinedNodeFlags(node);
+    const blockScopeKind = nodeFlags & 7 /* NodeFlags.BlockScoped */;
+    const name = node.name;
+    if (isBindingPattern(name)) {
+        if (blockScopeKind === 6 /* NodeFlags.AwaitUsing */)
+            return grammarErrorOnNode(g, node, 407 /* Diagnostics.X_0_declarations_may_not_have_binding_patterns */, 'await using');
+        if (blockScopeKind === 4 /* NodeFlags.Using */)
+            return grammarErrorOnNode(g, node, 407 /* Diagnostics.X_0_declarations_may_not_have_binding_patterns */, 'using');
+    }
+    const statement = node.parent.parent;
+    if (statement.kind !== 250 /* SyntaxKind.ForInStatement */ && statement.kind !== 251 /* SyntaxKind.ForOfStatement */) {
+        if ((nodeFlags & 8388608 /* NodeFlags.Ambient */) !== 0)
+            checkAmbientInitializer(g, node);
+        else if (node.initializer === undefined) {
+            if (isBindingPattern(name) && !isBindingPattern(node.parent))
+                return grammarErrorOnNode(g, node, 138 /* Diagnostics.A_destructuring_declaration_must_have_an_initializer */);
+            if (blockScopeKind === 6 /* NodeFlags.AwaitUsing */)
+                return grammarErrorOnNode(g, node, 115 /* Diagnostics.X_0_declarations_must_be_initialized */, 'await using');
+            if (blockScopeKind === 4 /* NodeFlags.Using */)
+                return grammarErrorOnNode(g, node, 115 /* Diagnostics.X_0_declarations_must_be_initialized */, 'using');
+            if (blockScopeKind === 2 /* NodeFlags.Const */)
+                return grammarErrorOnNode(g, node, 115 /* Diagnostics.X_0_declarations_must_be_initialized */, 'const');
+        }
+    }
+    const exclamationToken = node.exclamationToken;
+    if (exclamationToken !== undefined &&
+        (statement.kind !== 244 /* SyntaxKind.VariableStatement */ ||
+            node.type === undefined ||
+            node.initializer !== undefined ||
+            (nodeFlags & 8388608 /* NodeFlags.Ambient */) !== 0)) {
+        const message = node.initializer !== undefined
+            ? 212 /* Diagnostics.Declarations_with_initializers_cannot_also_have_definite_assignment_assertions */
+            : node.type === undefined
+                ? 213 /* Diagnostics.Declarations_with_definite_assignment_assertions_must_also_have_type_annotations */
+                : 205 /* Diagnostics.A_definite_assignment_assertion_is_not_permitted_in_this_context */;
+        return grammarErrorOnNode(g, exclamationToken, message);
+    }
+    if (getEmitModuleFormat(g) < ModuleKind.System &&
+        (statement.flags & 8388608 /* NodeFlags.Ambient */) === 0 &&
+        hasSyntacticModifier(statement, 32 /* ModifierFlags.Export */))
+        checkGrammarForEsModuleMarkerInBindingName(g, name);
+    // `let` can't be a name in `let` or `const` declarations.
+    return blockScopeKind !== 0 && checkGrammarNameInLetOrConstDeclarations(g, name);
+}
+function checkGrammarForEsModuleMarkerInBindingName(g, name) {
+    if (name instanceof Identifier)
+        return (name.text === '__esModule' &&
+            grammarErrorOnNode(g, name, 169 /* Diagnostics.Identifier_expected_esModule_is_reserved_as_an_exported_marker_when_transforming_ECMAScript_modules */));
+    for (const element of getElements(name).nodes) {
+        const elementName = getName(element);
+        if (elementName !== undefined)
+            return checkGrammarForEsModuleMarkerInBindingName(g, elementName);
+    }
+    return false;
+}
+function checkGrammarNameInLetOrConstDeclarations(g, name) {
+    if (name instanceof Identifier) {
+        const identifier = name;
+        if (identifier.text === 'let')
+            return grammarErrorOnNode(g, name, 643 /* Diagnostics.X_let_is_not_allowed_to_be_used_as_a_name_in_let_or_const_declarations */);
+        return false;
+    }
+    for (const element of getElements(name).nodes) {
+        const elementName = getName(element);
+        if (elementName !== undefined)
+            checkGrammarNameInLetOrConstDeclarations(g, elementName);
+    }
+    return false;
+}
+function checkGrammarBindingElement(g, node) {
+    if (node.dotDotDotToken !== undefined) {
+        const elements = getElements(node.parent);
+        if (node !== elements.nodes[elements.nodes.length - 1])
+            return grammarErrorOnNode(g, node, 628 /* Diagnostics.A_rest_element_must_be_last_in_a_destructuring_pattern */);
+        checkGrammarForDisallowedTrailingComma(g, elements, 9 /* Diagnostics.A_rest_parameter_or_binding_pattern_may_not_have_a_trailing_comma */);
+        if (node.propertyName !== undefined)
+            return grammarErrorOnNode(g, node.name, 720 /* Diagnostics.A_rest_element_cannot_have_a_property_name */);
+        // Report on the `=` before the initializer.
+        if (node.initializer !== undefined)
+            return grammarErrorAtPos(g, node.initializer.pos - 1, 1, 142 /* Diagnostics.A_rest_element_cannot_have_an_initializer */);
+    }
+    return false;
+}
+function checkGrammarForInOrForOfStatement(g, node) {
+    checkGrammarForInOrForOfStatementWorker(g, node);
+    // `checkForOfStatement` reports `for await` in static blocks after the statement's grammar.
+    const awaitModifier = node.awaitModifier;
+    if (node.kind === 251 /* SyntaxKind.ForOfStatement */ && awaitModifier !== undefined) {
+        const container = getContainingFunctionOrClassStaticBlock(node);
+        if (container !== undefined && container.kind === 176 /* SyntaxKind.ClassStaticBlockDeclaration */)
+            grammarErrorOnNode(g, awaitModifier, 1855 /* Diagnostics.X_for_await_loops_cannot_be_used_inside_a_class_static_block */);
+    }
+    return false;
+}
+function checkGrammarForInOrForOfStatementWorker(g, node) {
+    if (checkGrammarStatementInAmbientContext(g, node))
+        return true;
+    const awaitModifier = node.awaitModifier;
+    if (node.kind === 251 /* SyntaxKind.ForOfStatement */ &&
+        awaitModifier !== undefined &&
+        (node.flags & 8192 /* NodeFlags.AwaitContext */) === 0) {
+        if (isInTopLevelContext(node)) {
+            if (!g.hasParseErrors) {
+                if (!isEffectiveExternalModule(g))
+                    g.c.addDiagnostic(createDiagnosticForNode(awaitModifier, 357 /* Diagnostics.X_for_await_loops_are_only_allowed_at_the_top_level_of_a_file_when_that_file_is_a_module_but_this_file_has_no_imports_or_exports_Consider_adding_an_empty_export_to_make_this_file_a_module */, []));
+                const kind = checkTopLevelAwaitModule(g);
+                if (kind === 1 /* TopLevelAwaitSupport.CommonJS */)
+                    g.c.addDiagnostic(createDiagnosticForNode(awaitModifier, 247 /* Diagnostics.The_current_file_is_a_CommonJS_module_and_cannot_use_await_at_the_top_level */, []));
+                else if (kind === 2 /* TopLevelAwaitSupport.Unsupported */)
+                    g.c.addDiagnostic(createDiagnosticForNode(awaitModifier, 358 /* Diagnostics.Top_level_for_await_loops_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_node16_node18_node20_nodenext_or_preserve_and_the_target_option_is_set_to_es2017_or_higher */, []));
+            }
+        }
+        else if (!g.hasParseErrors) {
+            // `for await` in a function that isn't async.
+            const diagnostic = createDiagnosticForNode(awaitModifier, 72 /* Diagnostics.X_for_await_loops_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules */, []);
+            const containingFunction = getContainingFunction(node);
+            if (containingFunction !== undefined && containingFunction.kind !== 177 /* SyntaxKind.Constructor */)
+                addRelated(diagnostic, containingFunction, 290 /* Diagnostics.Did_you_mean_to_mark_this_function_as_async */);
+            g.c.addDiagnostic(diagnostic);
+            return true;
+        }
+    }
+    const initializer = node.initializer;
+    if (node.kind === 251 /* SyntaxKind.ForOfStatement */ &&
+        (node.flags & 8192 /* NodeFlags.AwaitContext */) === 0 &&
+        initializer instanceof Identifier &&
+        initializer.text === 'async') {
+        grammarErrorOnNode(g, initializer, 75 /* Diagnostics.The_left_hand_side_of_a_for_of_statement_may_not_be_async */);
+        return false;
+    }
+    if (initializer.kind !== 262 /* SyntaxKind.VariableDeclarationList */)
+        return false;
+    const list = initializer;
+    if (checkGrammarVariableDeclarationList(g, list))
+        return false;
+    // Declarations can be empty after a parse error, as in `for (let of x)`.
+    const declarations = list.declarations.nodes;
+    if (declarations.length === 0)
+        return false;
+    const isForIn = node.kind === 250 /* SyntaxKind.ForInStatement */;
+    if (declarations.length > 1)
+        return grammarErrorOnFirstToken(g, declarations[1], isForIn
+            ? 60 /* Diagnostics.Only_a_single_variable_declaration_is_allowed_in_a_for_in_statement */
+            : 144 /* Diagnostics.Only_a_single_variable_declaration_is_allowed_in_a_for_of_statement */);
+    const first = declarations[0];
+    if (first.initializer !== undefined)
+        return grammarErrorOnNode(g, first.name, isForIn
+            ? 145 /* Diagnostics.The_variable_declaration_of_a_for_in_statement_cannot_have_an_initializer */
+            : 146 /* Diagnostics.The_variable_declaration_of_a_for_of_statement_cannot_have_an_initializer */);
+    if (first.type !== undefined)
+        return grammarErrorOnNode(g, first, isForIn
+            ? 575 /* Diagnostics.The_left_hand_side_of_a_for_in_statement_cannot_use_a_type_annotation */
+            : 645 /* Diagnostics.The_left_hand_side_of_a_for_of_statement_cannot_use_a_type_annotation */);
+    return false;
+}
+/** Whether the module and target options allow top-level `await`. */
+function checkTopLevelAwaitModule(g) {
+    const moduleKind = g.moduleKind;
+    if (moduleKind >= ModuleKind.Node16 && moduleKind <= ModuleKind.NodeNext) {
+        if (g.metadata.impliedNodeFormat === ModuleKind.CommonJS)
+            return 1 /* TopLevelAwaitSupport.CommonJS */;
+    }
+    else if (moduleKind !== ModuleKind.ES2022 &&
+        moduleKind !== ModuleKind.ESNext &&
+        moduleKind !== ModuleKind.Preserve &&
+        moduleKind !== ModuleKind.System)
+        return 2 /* TopLevelAwaitSupport.Unsupported */;
+    return g.c.languageVersion >= ScriptTarget.ES2017 ? 0 /* TopLevelAwaitSupport.Supported */ : 2 /* TopLevelAwaitSupport.Unsupported */;
+}
+function checkGrammarBreakOrContinueStatement(g, node) {
+    const targetLabel = getLabel(node);
+    const isBreak = node.kind === 253 /* SyntaxKind.BreakStatement */;
+    for (let current = node; current !== undefined; current = current.parent) {
+        if (isFunctionLike(current) || current.kind === 176 /* SyntaxKind.ClassStaticBlockDeclaration */)
+            return grammarErrorOnNode(g, node, 76 /* Diagnostics.Jump_target_cannot_cross_function_boundary */);
+        if (current.kind === 257 /* SyntaxKind.LabeledStatement */) {
+            const labeled = current;
+            if (targetLabel !== undefined && labeled.label.text === getText(targetLabel)) {
+                // `continue` can only target labels of iteration statements.
+                if (!isBreak && !isIterationStatement(labeled.statement, true))
+                    return grammarErrorOnNode(g, node, 83 /* Diagnostics.A_continue_statement_can_only_jump_to_a_label_of_an_enclosing_iteration_statement */);
+                return false;
+            }
+        }
+        else if (current.kind === 256 /* SyntaxKind.SwitchStatement */) {
+            if (isBreak && targetLabel === undefined)
+                return false;
+        }
+        else if (isIterationStatement(current, false) && targetLabel === undefined) {
+            return false;
+        }
+    }
+    if (targetLabel !== undefined)
+        return grammarErrorOnNode(g, node, isBreak
+            ? 84 /* Diagnostics.A_break_statement_can_only_jump_to_a_label_of_an_enclosing_statement */
+            : 83 /* Diagnostics.A_continue_statement_can_only_jump_to_a_label_of_an_enclosing_iteration_statement */);
+    return grammarErrorOnNode(g, node, isBreak
+        ? 74 /* Diagnostics.A_break_statement_can_only_be_used_within_an_enclosing_iteration_or_switch_statement */
+        : 73 /* Diagnostics.A_continue_statement_can_only_be_used_within_an_enclosing_iteration_statement */);
+}
+function isIterationStatement(node, lookInLabeledStatements) {
+    switch (node.kind) {
+        case 249 /* SyntaxKind.ForStatement */:
+        case 250 /* SyntaxKind.ForInStatement */:
+        case 251 /* SyntaxKind.ForOfStatement */:
+        case 247 /* SyntaxKind.DoStatement */:
+        case 248 /* SyntaxKind.WhileStatement */:
+            return true;
+        case 257 /* SyntaxKind.LabeledStatement */:
+            return lookInLabeledStatements && isIterationStatement(node.statement, true);
+    }
+    return false;
+}
+/** Returns whether the statement's expression is checked. */
+function checkGrammarReturnStatement(g, node) {
+    if (checkGrammarStatementInAmbientContext(g, node))
+        return false;
+    const container = getContainingFunctionOrClassStaticBlock(node);
+    if (container !== undefined && container.kind === 176 /* SyntaxKind.ClassStaticBlockDeclaration */) {
+        grammarErrorOnFirstToken(g, node, 1857 /* Diagnostics.A_return_statement_cannot_be_used_inside_a_class_static_block */);
+        return false;
+    }
+    if (container === undefined) {
+        grammarErrorOnFirstToken(g, node, 77 /* Diagnostics.A_return_statement_can_only_be_used_within_a_function_body */);
+        return false;
+    }
+    return true;
+}
+function checkGrammarWithStatement(g, node) {
+    if (!checkGrammarStatementInAmbientContext(g, node) && (node.flags & 8192 /* NodeFlags.AwaitContext */) !== 0)
+        grammarErrorOnFirstToken(g, node, 245 /* Diagnostics.X_with_statements_are_not_allowed_in_an_async_function_block */);
+    // The body of a `with` statement isn't checked.
+    g.visitNode(node.expression);
+    const start = skipTrivia(g.file.text, node.pos);
+    grammarErrorAtPos(g, start, node.statement.pos - start, 581 /* Diagnostics.The_with_statement_is_not_supported_All_symbols_in_a_with_block_will_have_type_any */);
+}
+function checkGrammarSwitchStatement(g, node) {
+    checkGrammarStatementInAmbientContext(g, node);
+    let seenDefaultClause = false;
+    for (const clause of node.caseBlock.clauses.nodes) {
+        if (clause.kind !== 298 /* SyntaxKind.DefaultClause */)
+            continue;
+        if (!seenDefaultClause)
+            seenDefaultClause = true;
+        else {
+            grammarErrorOnNode(g, clause, 81 /* Diagnostics.A_default_clause_cannot_appear_more_than_once_in_a_switch_statement */);
+            return;
+        }
+    }
+}
+function checkGrammarLabeledStatement(g, node) {
+    if (checkGrammarStatementInAmbientContext(g, node))
+        return;
+    const label = node.label;
+    for (let current = node.parent; current !== undefined && !isFunctionLike(current); current = current.parent)
+        if (current.kind === 257 /* SyntaxKind.LabeledStatement */ && current.label.text === label.text) {
+            grammarErrorOnNode(g, label, 82 /* Diagnostics.Duplicate_label_0 */, label.text);
+            return;
+        }
+}
+function checkGrammarCatchClause(g, node) {
+    const declaration = node.variableDeclaration;
+    if (declaration === undefined)
+        return;
+    const typeNode = declaration.type;
+    if (typeNode !== undefined) {
+        const t = getTypeFromTypeNode(g.c, typeNode);
+        if ((t.flags & 3 /* TypeFlags.AnyOrUnknown */) === 0)
+            grammarErrorOnFirstToken(g, typeNode, 152 /* Diagnostics.Catch_clause_variable_type_annotation_must_be_any_or_unknown_if_specified */);
+    }
+    else if (declaration.initializer !== undefined) {
+        grammarErrorOnFirstToken(g, declaration.initializer, 153 /* Diagnostics.Catch_clause_variable_cannot_have_an_initializer */);
+    }
+    else {
+        const blockLocals = getLocals(node.block);
+        const locals = getLocals(node);
+        if (blockLocals === undefined || locals === undefined)
+            return;
+        for (const caughtName of locals.keys()) {
+            const blockLocal = blockLocals.get(caughtName);
+            if (blockLocal !== undefined &&
+                blockLocal.valueDeclaration !== undefined &&
+                (blockLocal.flags & 2 /* SymbolFlags.BlockScopedVariable */) !== 0)
+                grammarErrorOnNode(g, blockLocal.valueDeclaration, 652 /* Diagnostics.Cannot_redeclare_identifier_0_in_catch_clause */, caughtName);
+        }
+    }
+}
+function getContainingFunction(node) {
+    let current = node.parent;
+    while (current !== undefined && !isFunctionLike(current))
+        current = current.parent;
+    return current;
+}
+export function getContainingFunctionOrClassStaticBlock(node) {
+    let current = node.parent;
+    while (current !== undefined && !isFunctionLike(current) && current.kind !== 176 /* SyntaxKind.ClassStaticBlockDeclaration */)
+        current = current.parent;
+    return current;
+}
+// ---- Modules, imports and exports
+function checkGrammarTopLevelElementsForRequiredDeclareModifier(g, file) {
+    for (const statement of file.statements.nodes) {
+        if (!isDeclarationNode(statement) && statement.kind !== 244 /* SyntaxKind.VariableStatement */)
+            continue;
+        // Everything but interfaces, type aliases, imports and exports needs `declare` or `export`.
+        switch (statement.kind) {
+            case 265 /* SyntaxKind.InterfaceDeclaration */:
+            case 266 /* SyntaxKind.TypeAliasDeclaration */:
+            case 273 /* SyntaxKind.ImportDeclaration */:
+            case 346 /* SyntaxKind.JSImportDeclaration */:
+            case 272 /* SyntaxKind.ImportEqualsDeclaration */:
+            case 279 /* SyntaxKind.ExportDeclaration */:
+            case 278 /* SyntaxKind.ExportAssignment */:
+            case 271 /* SyntaxKind.NamespaceExportDeclaration */:
+                continue;
+        }
+        if (hasSyntacticModifier(statement, 128 /* ModifierFlags.Ambient */ | 32 /* ModifierFlags.Export */ | 2048 /* ModifierFlags.Default */))
+            continue;
+        if (grammarErrorOnFirstToken(g, statement, 33 /* Diagnostics.Top_level_declarations_in_d_ts_files_must_start_with_either_a_declare_or_export_modifier */))
+            return true;
+    }
+    return false;
+}
+function checkGrammarModuleElementContext(g, node, message) {
+    const parent = node.parent;
+    const isInAppropriateContext = parent.kind === 307 /* SyntaxKind.SourceFile */ ||
+        parent.kind === 269 /* SyntaxKind.ModuleBlock */ ||
+        parent.kind === 268 /* SyntaxKind.ModuleDeclaration */;
+    if (!isInAppropriateContext)
+        grammarErrorOnFirstToken(g, node, message);
+    return !isInAppropriateContext;
+}
+function checkGrammarModuleDeclaration(g, node) {
+    // The declaration check reports an illegal context and skips the rest.
+    const parent = node.parent.kind;
+    if (parent !== 307 /* SyntaxKind.SourceFile */ && parent !== 269 /* SyntaxKind.ModuleBlock */ && parent !== 268 /* SyntaxKind.ModuleDeclaration */)
+        return true;
+    if (!checkGrammarModifiers(g, node) &&
+        (node.flags & 8388608 /* NodeFlags.Ambient */) === 0 &&
+        node.name.kind === 10 /* SyntaxKind.StringLiteral */)
+        grammarErrorOnNode(g, node.name, 26 /* Diagnostics.Only_ambient_modules_can_use_quoted_names */);
+    return true;
+}
+/** Checks an import or export with a module specifier; reports and returns `false` if it is invalid. */
+function checkExternalImportOrExportDeclaration(g, node) {
+    const moduleName = getExternalModuleName(node);
+    // A missing name is a parse error.
+    if (moduleName === undefined || moduleName.pos === moduleName.end)
+        return false;
+    if (moduleName.kind !== 10 /* SyntaxKind.StringLiteral */) {
+        g.c.error(moduleName, 107 /* Diagnostics.String_literal_expected */);
+        return false;
+    }
+    const parent = node.parent;
+    const inAmbientExternalModule = parent.kind === 269 /* SyntaxKind.ModuleBlock */ && isAmbientModule(parent.parent);
+    if (parent.kind !== 307 /* SyntaxKind.SourceFile */ && !inAmbientExternalModule) {
+        g.c.error(moduleName, node.kind === 279 /* SyntaxKind.ExportDeclaration */
+            ? 150 /* Diagnostics.Export_declarations_are_not_permitted_in_a_namespace */
+            : 112 /* Diagnostics.Import_declarations_in_a_namespace_cannot_reference_a_module */);
+        return false;
+    }
+    if (inAmbientExternalModule &&
+        isExternalModuleNameRelative(moduleName.text) &&
+        !isModuleAugmentationExternal(parent.parent)) {
+        // Module augmentations report relative names when checking the augmentation.
+        g.c.error(node, 607 /* Diagnostics.Import_or_export_declaration_in_an_ambient_module_declaration_cannot_reference_module_through_relative_module_name */);
+        return false;
+    }
+    if (node.kind === 272 /* SyntaxKind.ImportEqualsDeclaration */)
+        return true;
+    const attributes = getImportAttributes(node);
+    if (attributes === undefined)
+        return true;
+    let hasError = false;
+    for (const attribute of attributes.attributes.nodes) {
+        const value = attribute.value;
+        if (value.kind !== 10 /* SyntaxKind.StringLiteral */) {
+            hasError = true;
+            g.c.error(value, 978 /* Diagnostics.Import_attribute_values_must_be_string_literal_expressions */);
+        }
+    }
+    return !hasError;
+}
+function getImportAttributes(node) {
+    if (node.kind === 273 /* SyntaxKind.ImportDeclaration */ || node.kind === 346 /* SyntaxKind.JSImportDeclaration */)
+        return node.attributes;
+    if (node.kind === 279 /* SyntaxKind.ExportDeclaration */)
+        return node.attributes;
+    return undefined;
+}
+function checkGrammarImportDeclaration(g, node) {
+    if (checkGrammarModuleElementContext(g, node, isInJSFile(node)
+        ? 388 /* Diagnostics.An_import_declaration_can_only_be_used_at_the_top_level_of_a_module */
+        : 182 /* Diagnostics.An_import_declaration_can_only_be_used_at_the_top_level_of_a_namespace_or_module */))
+        return;
+    if (!checkGrammarModifiers(g, node) && node.modifiers !== undefined)
+        grammarErrorOnFirstToken(g, node, 147 /* Diagnostics.An_import_declaration_cannot_have_modifiers */);
+    const clause = node.importClause;
+    if (checkExternalImportOrExportDeclaration(g, node) && clause !== undefined)
+        checkGrammarImportClause(g, clause);
+    checkGrammarImportAttributes(g, node);
+}
+function checkGrammarImportClause(g, node) {
+    const namedBindings = node.namedBindings;
+    if (node.phaseModifier === 156 /* SyntaxKind.TypeKeyword */) {
+        if ((node.flags & 4194304 /* NodeFlags.JSDoc */) === 0 && node.name !== undefined && namedBindings !== undefined)
+            return grammarErrorOnNode(g, node, 297 /* Diagnostics.A_type_only_import_can_specify_a_default_import_or_named_bindings_but_not_both */);
+        if (namedBindings !== undefined && namedBindings.kind === 276 /* SyntaxKind.NamedImports */)
+            return checkGrammarTypeOnlyNamedImportsOrExports(g, namedBindings);
+    }
+    else if (node.phaseModifier === 166 /* SyntaxKind.DeferKeyword */) {
+        if (node.name !== undefined)
+            return grammarErrorOnNode(g, node, 1873 /* Diagnostics.Default_imports_are_not_allowed_in_a_deferred_import */);
+        if (namedBindings !== undefined && namedBindings.kind === 276 /* SyntaxKind.NamedImports */)
+            return grammarErrorOnNode(g, node, 1874 /* Diagnostics.Named_imports_are_not_allowed_in_a_deferred_import */);
+        if (g.moduleKind !== ModuleKind.ESNext && g.moduleKind !== ModuleKind.Preserve)
+            return grammarErrorOnNode(g, node, 1875 /* Diagnostics.Deferred_imports_are_only_supported_when_the_module_flag_is_set_to_esnext_or_preserve */);
+    }
+    return false;
+}
+function checkGrammarTypeOnlyNamedImportsOrExports(g, namedBindings) {
+    const isImport = namedBindings.kind === 276 /* SyntaxKind.NamedImports */;
+    for (const specifier of getElements(namedBindings).nodes)
+        if (getIsTypeOnly(specifier))
+            return grammarErrorOnFirstToken(g, specifier, isImport
+                ? 471 /* Diagnostics.The_type_modifier_cannot_be_used_on_a_named_import_when_import_type_is_used_on_its_import_statement */
+                : 472 /* Diagnostics.The_type_modifier_cannot_be_used_on_a_named_export_when_export_type_is_used_on_its_export_statement */);
+    return false;
+}
+function checkGrammarImportEqualsDeclaration(g, node) {
+    if (checkGrammarModuleElementContext(g, node, isInJSFile(node)
+        ? 388 /* Diagnostics.An_import_declaration_can_only_be_used_at_the_top_level_of_a_module */
+        : 182 /* Diagnostics.An_import_declaration_can_only_be_used_at_the_top_level_of_a_namespace_or_module */))
+        return;
+    checkGrammarModifiers(g, node);
+    const isExternal = node.moduleReference.kind === 284 /* SyntaxKind.ExternalModuleReference */;
+    if (!isExternal) {
+        if (node.isTypeOnly) {
+            const symbol = getSymbolOfDeclaration(g.c, node);
+            if (symbol !== undefined && resolveAlias(g.c, symbol) !== g.c.unknownSymbol)
+                grammarErrorOnNode(g, node, 318 /* Diagnostics.An_import_alias_cannot_use_import_type */);
+        }
+        return;
+    }
+    if (checkExternalImportOrExportDeclaration(g, node) &&
+        g.moduleKind >= ModuleKind.ES2015 &&
+        g.moduleKind <= ModuleKind.ESNext &&
+        !node.isTypeOnly &&
+        (node.flags & 8388608 /* NodeFlags.Ambient */) === 0)
+        // Import assignments can't be emitted as ECMAScript modules.
+        grammarErrorOnNode(g, node, 157 /* Diagnostics.Import_assignment_cannot_be_used_when_targeting_ECMAScript_modules_Consider_using_import_Asterisk_as_ns_from_mod_import_a_from_mod_import_d_from_mod_or_another_module_format_instead */);
+}
+function checkGrammarExportDeclaration(g, node) {
+    if (checkGrammarModuleElementContext(g, node, 183 /* Diagnostics.An_export_declaration_can_only_be_used_at_the_top_level_of_a_namespace_or_module */))
+        return;
+    if (!checkGrammarModifiers(g, node) && node.modifiers !== undefined)
+        grammarErrorOnFirstToken(g, node, 149 /* Diagnostics.An_export_declaration_cannot_have_modifiers */);
+    const clause = node.exportClause;
+    if (node.isTypeOnly && clause !== undefined && clause.kind === 280 /* SyntaxKind.NamedExports */)
+        checkGrammarTypeOnlyNamedImportsOrExports(g, clause);
+    const hasModuleSpecifier = node.moduleSpecifier !== undefined;
+    if ((!hasModuleSpecifier || checkExternalImportOrExportDeclaration(g, node)) &&
+        clause !== undefined &&
+        clause.kind === 280 /* SyntaxKind.NamedExports */) {
+        for (const specifier of getElements(clause).nodes) {
+            checkGrammarModuleExportName(g, specifier.propertyName, hasModuleSpecifier);
+            checkGrammarModuleExportName(g, specifier.name, true);
+        }
+        const parent = node.parent;
+        const inAmbientExternalModule = parent.kind === 269 /* SyntaxKind.ModuleBlock */ && isAmbientModule(parent.parent);
+        const inAmbientNamespaceDeclaration = !inAmbientExternalModule &&
+            parent.kind === 269 /* SyntaxKind.ModuleBlock */ &&
+            !hasModuleSpecifier &&
+            (node.flags & 8388608 /* NodeFlags.Ambient */) !== 0;
+        if (parent.kind !== 307 /* SyntaxKind.SourceFile */ && !inAmbientExternalModule && !inAmbientNamespaceDeclaration)
+            g.c.error(node, 150 /* Diagnostics.Export_declarations_are_not_permitted_in_a_namespace */);
+    }
+    checkGrammarImportAttributes(g, node);
+}
+function checkGrammarModuleExportName(g, name, allowStringLiteral) {
+    if (name === undefined || name.kind !== 10 /* SyntaxKind.StringLiteral */)
+        return;
+    if (!allowStringLiteral)
+        grammarErrorOnNode(g, name, 1 /* Diagnostics.Identifier_expected */);
+    else if ((g.moduleKind === ModuleKind.ES2015 || g.moduleKind === ModuleKind.ES2020) && !g.file.isDeclarationFile)
+        grammarErrorOnNode(g, name, 1872 /* Diagnostics.String_literal_import_and_export_names_are_not_supported_when_the_module_flag_is_set_to_es2015_or_es2020 */);
+}
+/** Returns whether the export's expression is checked. */
+function checkGrammarExportAssignment(g, node) {
+    const isExportEquals = node.isExportEquals;
+    if (checkGrammarModuleElementContext(g, node, isExportEquals
+        ? 181 /* Diagnostics.An_export_assignment_must_be_at_the_top_level_of_a_file_or_module_declaration */
+        : 207 /* Diagnostics.A_default_export_must_be_at_the_top_level_of_a_file_or_module_declaration */))
+        return false;
+    const parent = node.parent;
+    const container = parent.kind === 307 /* SyntaxKind.SourceFile */ ? parent : parent.parent;
+    if (container.kind === 268 /* SyntaxKind.ModuleDeclaration */ && !isAmbientModule(container)) {
+        g.c.error(node, isExportEquals
+            ? 48 /* Diagnostics.An_export_assignment_cannot_be_used_in_a_namespace */
+            : 255 /* Diagnostics.A_default_export_can_only_be_used_in_an_ECMAScript_style_module */);
+        return false;
+    }
+    if (!checkGrammarModifiers(g, node) && node.modifiers !== undefined)
+        grammarErrorOnFirstToken(g, node, 88 /* Diagnostics.An_export_assignment_cannot_have_modifiers */);
+    const isAmbient = (node.flags & 8388608 /* NodeFlags.Ambient */) !== 0;
+    if (isAmbient && !isEntityNameExpression(node.expression, false))
+        grammarErrorOnNode(g, node.expression, 846 /* Diagnostics.The_expression_of_an_export_assignment_must_be_an_identifier_or_qualified_name_in_an_ambient_context */);
+    if (isExportEquals) {
+        const impliedFormat = getImpliedNodeFormatForEmit(g.file.fileName, g.moduleKind, g.metadata);
+        // Export assignments aren't supported in ECMAScript modules.
+        if (g.moduleKind >= ModuleKind.ES2015 &&
+            g.moduleKind !== ModuleKind.Preserve &&
+            (isAmbient ? impliedFormat === ModuleKind.ESNext : impliedFormat !== ModuleKind.CommonJS))
+            grammarErrorOnNode(g, node, 158 /* Diagnostics.Export_assignment_cannot_be_used_when_targeting_ECMAScript_modules_Consider_using_export_default_or_another_module_format_instead */);
+        else if (g.moduleKind === ModuleKind.System && !isAmbient)
+            grammarErrorOnNode(g, node, 170 /* Diagnostics.Export_assignment_is_not_supported_when_module_flag_is_system */);
+    }
+    return true;
+}
+function getEmitModuleFormat(g) {
+    return getEmitModuleFormatOfFile(g.file.fileName, g.c.compilerOptions, g.metadata);
+}
+function isEffectiveExternalModule(g) {
+    if (isExternalModule(g.file))
+        return true;
+    const moduleKind = g.moduleKind;
+    const commonJSContaining = moduleKind === ModuleKind.CommonJS || (moduleKind >= ModuleKind.Node16 && moduleKind <= ModuleKind.NodeNext);
+    return commonJSContaining && g.file.commonJSModuleIndicator !== undefined;
+}
+// ---- Type nodes
+function checkGrammarTypeReference(g, node) {
+    checkGrammarTypeArguments(g, node.typeArguments);
+    const typeArguments = node.typeArguments;
+    if ((node.flags & 4194304 /* NodeFlags.JSDoc */) !== 0 || typeArguments === undefined || node.typeName.end === typeArguments.pos)
+        return;
+    // `Foo.<T>` is JSDoc syntax. A token starting with `<`, as in `Foo<T>`, is not a dot, which
+    // saves creating a scanner over the file.
+    if (g.file.text.charCodeAt(node.typeName.end) === 60 /* CharacterCodes.lessThan */)
+        return;
+    const scanner = g.getScanner();
+    scanner.resetTokenState(node.typeName.end);
+    if (scanner.scan() === 24 /* SyntaxKind.DotToken */)
+        grammarErrorAtPos(g, skipTrivia(g.file.text, node.typeName.end), 1, 1749 /* Diagnostics.JSDoc_types_can_only_be_used_inside_documentation_comments */);
+}
+function checkGrammarTypeOperatorNode(g, node) {
+    const innerType = node.type;
+    if (node.operator === 158 /* SyntaxKind.UniqueKeyword */) {
+        if (innerType.kind !== 155 /* SyntaxKind.SymbolKeyword */)
+            return grammarErrorOnNode(g, innerType, 2 /* Diagnostics.X_0_expected */, tokenToString(155 /* SyntaxKind.SymbolKeyword */));
+        let parent = node.parent;
+        while (parent.kind === 197 /* SyntaxKind.ParenthesizedType */)
+            parent = parent.parent;
+        switch (parent.kind) {
+            case 261 /* SyntaxKind.VariableDeclaration */: {
+                const declaration = parent;
+                if (declaration.name.kind !== 79 /* SyntaxKind.Identifier */)
+                    return grammarErrorOnNode(g, node, 269 /* Diagnostics.X_unique_symbol_types_may_not_be_used_on_a_variable_declaration_with_a_binding_name */);
+                if (!(declaration.parent.kind === 262 /* SyntaxKind.VariableDeclarationList */ &&
+                    declaration.parent.parent.kind === 244 /* SyntaxKind.VariableStatement */))
+                    return grammarErrorOnNode(g, node, 270 /* Diagnostics.X_unique_symbol_types_are_only_allowed_on_variables_in_a_variable_statement */);
+                if ((declaration.parent.flags & 2 /* NodeFlags.Const */) === 0)
+                    return grammarErrorOnNode(g, declaration.name, 268 /* Diagnostics.A_variable_whose_type_is_a_unique_symbol_type_must_be_const */);
+                return false;
+            }
+            case 173 /* SyntaxKind.PropertyDeclaration */:
+                if (!isStatic(parent) || !hasSyntacticModifier(parent, 8 /* ModifierFlags.Readonly */))
+                    return grammarErrorOnNode(g, getName(parent), 267 /* Diagnostics.A_property_of_a_class_whose_type_is_a_unique_symbol_type_must_be_both_static_and_readonly */);
+                return false;
+            case 172 /* SyntaxKind.PropertySignature */:
+                if (!hasSyntacticModifier(parent, 8 /* ModifierFlags.Readonly */))
+                    return grammarErrorOnNode(g, getName(parent), 266 /* Diagnostics.A_property_of_an_interface_or_type_literal_whose_type_is_a_unique_symbol_type_must_be_readonly */);
+                return false;
+        }
+        return grammarErrorOnNode(g, node, 271 /* Diagnostics.X_unique_symbol_types_are_not_allowed_here */);
+    }
+    if (node.operator === 148 /* SyntaxKind.ReadonlyKeyword */ &&
+        innerType.kind !== 189 /* SyntaxKind.ArrayType */ &&
+        innerType.kind !== 190 /* SyntaxKind.TupleType */)
+        return grammarErrorOnFirstToken(g, node, 288 /* Diagnostics.X_readonly_type_modifier_is_only_permitted_on_array_and_tuple_literal_types */, tokenToString(155 /* SyntaxKind.SymbolKeyword */));
+    return false;
+}
+function checkGrammarInferType(g, node) {
+    for (let current = node; current !== undefined; current = current.parent) {
+        const parent = current.parent;
+        if (parent !== undefined &&
+            parent.kind === 195 /* SyntaxKind.ConditionalType */ &&
+            parent.extendsType === current)
+            return;
+    }
+    grammarErrorOnNode(g, node, 273 /* Diagnostics.X_infer_declarations_are_only_permitted_in_the_extends_clause_of_a_conditional_type */);
+}
+function checkGrammarTupleType(g, node) {
+    let seenOptionalElement = false;
+    let seenRestElement = false;
+    for (const element of node.elements.nodes) {
+        let flags = getTupleElementFlags(g.c, element);
+        if ((flags & 8 /* ElementFlags.Variadic */) !== 0) {
+            const t = getTypeFromTypeNode(g.c, getType(element));
+            // `checkTupleType` reports non-array rest types and stops.
+            if (!isArrayLikeType(g.c, t))
+                break;
+            if (isArrayType(g.c, t) || (isTupleType(t) && (tupleTargetOf(t).combinedFlags & 4 /* ElementFlags.Rest */) !== 0))
+                flags |= 4 /* ElementFlags.Rest */;
+        }
+        if ((flags & 4 /* ElementFlags.Rest */) !== 0) {
+            if (seenRestElement) {
+                grammarErrorOnNode(g, element, 214 /* Diagnostics.A_rest_element_cannot_follow_another_rest_element */);
+                break;
+            }
+            seenRestElement = true;
+        }
+        else if ((flags & 2 /* ElementFlags.Optional */) !== 0) {
+            if (seenRestElement) {
+                grammarErrorOnNode(g, element, 215 /* Diagnostics.An_optional_element_cannot_follow_a_rest_element */);
+                break;
+            }
+            seenOptionalElement = true;
+        }
+        else if ((flags & 1 /* ElementFlags.Required */) !== 0 && seenOptionalElement) {
+            grammarErrorOnNode(g, element, 206 /* Diagnostics.A_required_element_cannot_follow_an_optional_element */);
+            break;
+        }
+    }
+}
+function checkGrammarNamedTupleMember(g, node) {
+    if (node.dotDotDotToken !== undefined && node.questionToken !== undefined)
+        grammarErrorOnNode(g, node, 1159 /* Diagnostics.A_tuple_member_cannot_be_both_optional_and_rest */);
+    if (node.type.kind === 191 /* SyntaxKind.OptionalType */)
+        grammarErrorOnNode(g, node.type, 1160 /* Diagnostics.A_labeled_tuple_element_is_declared_as_optional_with_a_question_mark_after_the_name_and_before_the_colon_rather_than_after_the_type */);
+    if (node.type.kind === 192 /* SyntaxKind.RestType */)
+        grammarErrorOnNode(g, node.type, 1161 /* Diagnostics.A_labeled_tuple_element_is_declared_as_rest_with_a_before_the_name_rather_than_before_the_type */);
+}
+/** JSDoc-only type syntax in TypeScript code. */
+function checkGrammarJSDocTypeInTypeScript(g, node) {
+    if ((node.flags & 65536 /* NodeFlags.JavaScriptFile */) !== 0)
+        return;
+    if (node.kind !== 312 /* SyntaxKind.JSDocNonNullableType */ && node.kind !== 311 /* SyntaxKind.JSDocNullableType */) {
+        grammarErrorOnNode(g, node, 1749 /* Diagnostics.JSDoc_types_can_only_be_used_inside_documentation_comments */);
+        return;
+    }
+    const isNullable = node.kind === 311 /* SyntaxKind.JSDocNullableType */;
+    const typeNode = getType(node);
+    const postfix = node.pos === typeNode.pos;
+    let t = getTypeFromTypeNode(g.c, typeNode);
+    if (isNullable && t !== g.c.neverType && t !== g.c.voidType)
+        t = getNullableType(g.c, t, postfix ? 4 /* TypeFlags.Undefined */ : 12 /* TypeFlags.Nullable */);
+    grammarErrorOnNode(g, node, postfix
+        ? 1822 /* Diagnostics.X_0_at_the_end_of_a_type_is_not_valid_TypeScript_syntax_Did_you_mean_to_write_1 */
+        : 1823 /* Diagnostics.X_0_at_the_start_of_a_type_is_not_valid_TypeScript_syntax_Did_you_mean_to_write_1 */, isNullable ? '?' : '!', typeToString(g.c, t));
+}
+/** The `resolution-mode` of import type attributes, as tsgo's `getResolutionModeOverride`. */
+function getResolutionModeOverride(g, node, reportErrors) {
+    const attributes = node.attributes.nodes;
+    if (attributes.length !== 1) {
+        if (reportErrors)
+            grammarErrorOnNode(g, node, 384 /* Diagnostics.Type_import_attributes_should_have_exactly_one_key_resolution_mode_with_value_import_or_require */);
+        return ModuleKind.None;
+    }
+    const attribute = attributes[0];
+    const name = attribute.name;
+    if (name === undefined || !isStringLiteralLike(name))
+        return ModuleKind.None;
+    if (getText(name) !== 'resolution-mode') {
+        if (reportErrors)
+            grammarErrorOnNode(g, name, 383 /* Diagnostics.X_resolution_mode_is_the_only_valid_key_for_type_import_attributes */);
+        return ModuleKind.None;
+    }
+    const value = attribute.value;
+    if (!isStringLiteralLike(value))
+        return ModuleKind.None;
+    const text = getText(value);
+    if (text === 'import')
+        return ModuleKind.ESNext;
+    if (text === 'require')
+        return ModuleKind.CommonJS;
+    if (reportErrors)
+        grammarErrorOnNode(g, value, 374 /* Diagnostics.X_resolution_mode_should_be_either_require_or_import */);
+    return ModuleKind.None;
+}
+/** The grammar of `checkImportAttributes` for import and export declarations. */
+function checkGrammarImportAttributes(g, declaration) {
+    const node = getImportAttributes(declaration);
+    if (node === undefined)
+        return;
+    const isTypeOnly = isExclusivelyTypeOnlyImportOrExport(declaration);
+    const override = getResolutionModeOverride(g, node, isTypeOnly);
+    // Other checks don't apply to type-only imports with a resolution mode.
+    if (isTypeOnly && override !== ModuleKind.None)
+        return;
+    const moduleKind = g.moduleKind;
+    if (!((moduleKind >= ModuleKind.Node18 && moduleKind <= ModuleKind.NodeNext) ||
+        moduleKind === ModuleKind.Preserve ||
+        moduleKind === ModuleKind.ESNext)) {
+        grammarErrorOnNode(g, node, 954 /* Diagnostics.Import_attributes_are_only_supported_when_the_module_option_is_set_to_esnext_node18_node20_nodenext_or_preserve */);
+        return;
+    }
+    const moduleSpecifier = getExternalModuleName(declaration);
+    if (moduleSpecifier !== undefined &&
+        isStringLiteralLike(moduleSpecifier) &&
+        getEmitSyntaxOfImportOrExport(g) === ModuleKind.CommonJS) {
+        grammarErrorOnNode(g, node, 976 /* Diagnostics.Import_attributes_are_not_allowed_on_statements_that_compile_to_CommonJS_require_calls */);
+        return;
+    }
+    if (isTypeOnly) {
+        grammarErrorOnNode(g, node, 977 /* Diagnostics.Import_attributes_cannot_be_used_with_type_only_imports_or_exports */);
+        return;
+    }
+    if (override !== ModuleKind.None)
+        grammarErrorOnNode(g, node, 375 /* Diagnostics.X_resolution_mode_can_only_be_set_for_type_only_imports */);
+}
+function isExclusivelyTypeOnlyImportOrExport(node) {
+    if (node.kind === 279 /* SyntaxKind.ExportDeclaration */)
+        return node.isTypeOnly;
+    if (node.kind !== 273 /* SyntaxKind.ImportDeclaration */ && node.kind !== 346 /* SyntaxKind.JSImportDeclaration */)
+        return false;
+    const clause = node.importClause;
+    return clause !== undefined && clause.phaseModifier === 156 /* SyntaxKind.TypeKeyword */;
+}
+/** The module syntax an import or export declaration is emitted as. */
+function getEmitSyntaxOfImportOrExport(g) {
+    const format = getEmitModuleFormat(g);
+    if (format === ModuleKind.CommonJS)
+        return ModuleKind.CommonJS;
+    if ((format >= ModuleKind.ES2015 && format <= ModuleKind.ESNext) || format === ModuleKind.Preserve)
+        return ModuleKind.ESNext;
+    return ModuleKind.None;
+}
+function checkGrammarObjectLiteralExpression(g, node, inDestructuring) {
+    const seen = new Map();
+    for (const property of node.properties.nodes) {
+        if (property.kind === 305 /* SyntaxKind.SpreadAssignment */) {
+            if (inDestructuring) {
+                // A rest property can't be destructured further.
+                const expression = skipParentheses(getExpression(property));
+                if (expression.kind === 210 /* SyntaxKind.ArrayLiteralExpression */ ||
+                    expression.kind === 211 /* SyntaxKind.ObjectLiteralExpression */)
+                    return grammarErrorOnNode(g, getExpression(property), 661 /* Diagnostics.A_rest_element_cannot_contain_a_binding_pattern */);
+            }
+            continue;
+        }
+        const name = getName(property);
+        if (name.kind === 168 /* SyntaxKind.ComputedPropertyName */)
+            checkGrammarComputedPropertyName(g, name);
+        if (property.kind === 304 /* SyntaxKind.ShorthandPropertyAssignment */ && !inDestructuring) {
+            // An initializer is only valid in a destructuring pattern; report on the `=`.
+            const shorthand = property;
+            const equalsToken = shorthand.equalsToken;
+            if (shorthand.objectAssignmentInitializer !== undefined)
+                grammarErrorOnFirstToken(g, equalsToken !== undefined ? equalsToken : shorthand.name, 248 /* Diagnostics.Did_you_mean_to_use_a_Colon_An_can_only_follow_a_property_name_when_the_containing_object_literal_is_part_of_a_destructuring_pattern */);
+        }
+        if (name.kind === 80 /* SyntaxKind.PrivateIdentifier */)
+            grammarErrorOnNode(g, name, 1838 /* Diagnostics.Private_identifiers_are_not_allowed_outside_class_bodies */);
+        // Only `async` is allowed, and only on methods.
+        const modifiers = getModifiers(property);
+        if (modifiers !== undefined)
+            for (const modifier of modifiers.nodes)
+                if (isModifierKind(modifier.kind) &&
+                    (modifier.kind !== 133 /* SyntaxKind.AsyncKeyword */ || property.kind !== 175 /* SyntaxKind.MethodDeclaration */))
+                    grammarErrorOnNode(g, modifier, 31 /* Diagnostics.X_0_modifier_cannot_be_used_here */, getTextOfNodeFromSourceText(g.file.text, modifier));
+        // Duplicate data properties are errors in strict mode only, but accessors and data
+        // properties never mix, and get/set accessors can't repeat (ECMA-262 11.1.5).
+        let currentKind;
+        switch (property.kind) {
+            case 304 /* SyntaxKind.ShorthandPropertyAssignment */:
+            case 303 /* SyntaxKind.PropertyAssignment */: {
+                const postfixToken = getPostfixToken(property);
+                checkGrammarForInvalidExclamationToken(g, postfixToken, 205 /* Diagnostics.A_definite_assignment_assertion_is_not_permitted_in_this_context */);
+                checkGrammarForInvalidQuestionMark(g, postfixToken, 119 /* Diagnostics.An_object_member_cannot_be_declared_optional */);
+                if (name.kind === 9 /* SyntaxKind.BigIntLiteral */)
+                    g.c.addDiagnostic(createDiagnosticForNode(name, 454 /* Diagnostics.A_bigint_literal_cannot_be_used_as_a_property_name */, []));
+                currentKind = 4 /* DeclarationMeaning.PropertyAssignment */;
+                break;
+            }
+            case 175 /* SyntaxKind.MethodDeclaration */:
+                currentKind = 8 /* DeclarationMeaning.Method */;
+                break;
+            case 178 /* SyntaxKind.GetAccessor */:
+                currentKind = 1 /* DeclarationMeaning.GetAccessor */;
+                break;
+            default:
+                currentKind = 2 /* DeclarationMeaning.SetAccessor */;
+                break;
+        }
+        if (inDestructuring)
+            continue;
+        const effectiveName = getEffectivePropertyNameForPropertyNameNode(g.c, name);
+        if (effectiveName === undefined)
+            continue;
+        const existingKind = seen.get(effectiveName);
+        if (existingKind === undefined) {
+            seen.set(effectiveName, currentKind);
+            continue;
+        }
+        if ((currentKind & 8 /* DeclarationMeaning.Method */) !== 0 && (existingKind & 8 /* DeclarationMeaning.Method */) !== 0)
+            grammarErrorOnNode(g, name, 478 /* Diagnostics.Duplicate_identifier_0 */, getTextOfNodeFromSourceText(g.file.text, name));
+        else if ((currentKind & 4 /* DeclarationMeaning.PropertyAssignment */) !== 0 &&
+            (existingKind & 4 /* DeclarationMeaning.PropertyAssignment */) !== 0)
+            grammarErrorOnNode(g, name, 85 /* Diagnostics.An_object_literal_cannot_have_multiple_properties_with_the_same_name */, getTextOfNodeFromSourceText(g.file.text, name));
+        else if ((currentKind & 3 /* DeclarationMeaning.GetOrSetAccessor */) !== 0 &&
+            (existingKind & 3 /* DeclarationMeaning.GetOrSetAccessor */) !== 0) {
+            if (existingKind !== 3 /* DeclarationMeaning.GetOrSetAccessor */ && currentKind !== existingKind)
+                seen.set(effectiveName, currentKind | existingKind);
+            else
+                return grammarErrorOnNode(g, name, 86 /* Diagnostics.An_object_literal_cannot_have_multiple_get_Slashset_accessors_with_the_same_name */);
+        }
+        else {
+            return grammarErrorOnNode(g, name, 87 /* Diagnostics.An_object_literal_cannot_have_property_and_accessor_with_the_same_name */);
+        }
+    }
+    return false;
+}
+/** The property name a literal or computed name denotes, if known. */
+function getEffectivePropertyNameForPropertyNameNode(c, name) {
+    switch (name.kind) {
+        case 79 /* SyntaxKind.Identifier */:
+        case 80 /* SyntaxKind.PrivateIdentifier */:
+        case 10 /* SyntaxKind.StringLiteral */:
+        case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */:
+        case 8 /* SyntaxKind.NumericLiteral */:
+        case 9 /* SyntaxKind.BigIntLiteral */:
+            return getText(name);
+        case 168 /* SyntaxKind.ComputedPropertyName */: {
+            const expression = name.expression;
+            switch (expression.kind) {
+                case 10 /* SyntaxKind.StringLiteral */:
+                case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */:
+                case 8 /* SyntaxKind.NumericLiteral */:
+                    return getText(expression);
+                case 225 /* SyntaxKind.PrefixUnaryExpression */: {
+                    const unary = expression;
+                    if (unary.operand.kind === 8 /* SyntaxKind.NumericLiteral */ &&
+                        (unary.operator === 40 /* SyntaxKind.MinusToken */ || unary.operator === 39 /* SyntaxKind.PlusToken */))
+                        return unary.operator === 40 /* SyntaxKind.MinusToken */ ? '-' + getText(unary.operand) : getText(unary.operand);
+                    break;
+                }
+            }
+            const t = getTypeOfExpression(c, expression);
+            return (t.flags & (16384 /* TypeFlags.UniqueESSymbol */ | 1024 /* TypeFlags.StringLiteral */ | 2048 /* TypeFlags.NumberLiteral */)) !== 0
+                ? getPropertyNameFromType(t)
+                : undefined;
+        }
+    }
+    return undefined;
+}
+function checkGrammarCallExpression(g, node) {
+    const callee = node.expression;
+    const isImportCall = callee.kind === 101 /* SyntaxKind.ImportKeyword */ ||
+        (callee.kind === 237 /* SyntaxKind.MetaProperty */ &&
+            callee.keywordToken === 101 /* SyntaxKind.ImportKeyword */ &&
+            callee.name.text === 'defer');
+    if (isImportCall)
+        checkGrammarImportCallExpression(g, node);
+    else
+        checkGrammarTypeArguments(g, node.typeArguments);
+}
+function checkGrammarImportCallExpression(g, node) {
+    const moduleKind = g.moduleKind;
+    if (g.c.compilerOptions.verbatimModuleSyntax === true && moduleKind === ModuleKind.CommonJS)
+        return grammarErrorOnNode(g, node, fileExtensionIsOneOf(g.file.fileName, ['.cts', '.cjs'])
+            ? 235 /* Diagnostics.ECMAScript_imports_and_exports_cannot_be_written_in_a_CommonJS_file_under_verbatimModuleSyntax */
+            : 244 /* Diagnostics.ECMAScript_imports_and_exports_cannot_be_written_in_a_CommonJS_file_under_verbatimModuleSyntax_Adjust_the_type_field_in_the_nearest_package_json_to_make_this_file_an_ECMAScript_module_or_adjust_your_verbatimModuleSyntax_module_and_moduleResolution_settings_in_TypeScript */);
+    if (node.expression.kind === 237 /* SyntaxKind.MetaProperty */) {
+        if (moduleKind !== ModuleKind.ESNext && moduleKind !== ModuleKind.Preserve)
+            return grammarErrorOnNode(g, node, 1875 /* Diagnostics.Deferred_imports_are_only_supported_when_the_module_flag_is_set_to_esnext_or_preserve */);
+    }
+    else if (moduleKind === ModuleKind.ES2015)
+        return grammarErrorOnNode(g, node, 259 /* Diagnostics.Dynamic_imports_are_only_supported_when_the_module_flag_is_set_to_es2020_es2022_esnext_commonjs_amd_system_umd_node16_node18_node20_or_nodenext */);
+    if (node.typeArguments !== undefined)
+        return grammarErrorOnNode(g, node, 262 /* Diagnostics.This_use_of_import_is_invalid_import_calls_can_be_written_but_they_must_have_parentheses_and_cannot_have_type_arguments */);
+    const args = node.arguments;
+    const argumentNodes = args.nodes;
+    if (!(moduleKind >= ModuleKind.Node16 && moduleKind <= ModuleKind.NodeNext) &&
+        moduleKind !== ModuleKind.ESNext &&
+        moduleKind !== ModuleKind.Preserve) {
+        // Import attributes allow a trailing comma.
+        checkGrammarForDisallowedTrailingComma(g, args, 5 /* Diagnostics.Trailing_comma_not_allowed */);
+        if (argumentNodes.length > 1)
+            return grammarErrorOnNode(g, argumentNodes[1], 260 /* Diagnostics.Dynamic_imports_only_support_a_second_argument_when_the_module_option_is_set_to_esnext_node16_node18_node20_nodenext_or_preserve */);
+    }
+    if (argumentNodes.length === 0 || argumentNodes.length > 2)
+        return grammarErrorOnNode(g, node, 372 /* Diagnostics.Dynamic_imports_can_only_accept_a_module_specifier_and_an_optional_set_of_attributes_as_arguments */);
+    // Arguments are parsed like array elements, which allows spreads.
+    for (const argument of argumentNodes)
+        if (argument.kind === 231 /* SyntaxKind.SpreadElement */)
+            return grammarErrorOnNode(g, argument, 261 /* Diagnostics.Argument_of_dynamic_import_cannot_be_spread_element */);
+    return false;
+}
+function checkGrammarTaggedTemplateChain(g, node) {
+    if (node.questionDotToken === undefined && (node.flags & 32 /* NodeFlags.OptionalChain */) === 0)
+        return false;
+    return grammarErrorOnNode(g, node.template, 292 /* Diagnostics.Tagged_template_expressions_are_not_permitted_in_an_optional_chain */);
+}
+function checkGrammarMetaProperty(g, node) {
+    const name = node.name;
+    const nameText = name.text;
+    if (node.keywordToken === 104 /* SyntaxKind.NewKeyword */) {
+        if (nameText !== 'target')
+            return grammarErrorOnNode(g, name, 1815 /* Diagnostics.X_0_is_not_a_valid_meta_property_for_keyword_1_Did_you_mean_2 */, nameText, tokenToString(node.keywordToken), 'target');
+    }
+    else if (node.keywordToken === 101 /* SyntaxKind.ImportKeyword */ && nameText !== 'meta') {
+        const parent = node.parent;
+        const isCallee = parent.kind === 214 /* SyntaxKind.CallExpression */ && parent.expression === node;
+        if (nameText === 'defer') {
+            if (!isCallee)
+                return grammarErrorAtPos(g, node.end, 0, 2 /* Diagnostics.X_0_expected */, '(');
+        }
+        else {
+            if (isCallee)
+                return grammarErrorOnNode(g, name, 1876 /* Diagnostics.X_0_is_not_a_valid_meta_property_for_keyword_import_Did_you_mean_meta_or_defer */, nameText);
+            return grammarErrorOnNode(g, name, 1815 /* Diagnostics.X_0_is_not_a_valid_meta_property_for_keyword_1_Did_you_mean_2 */, nameText, tokenToString(node.keywordToken), 'meta');
+        }
+    }
+    return false;
+}
+function checkGrammarAwaitOrAwaitUsing(g, node) {
+    const isAwaitExpression = node.kind === 224 /* SyntaxKind.AwaitExpression */;
+    let hasError = false;
+    const container = getContainingFunctionOrClassStaticBlock(node);
+    if (container !== undefined && container.kind === 176 /* SyntaxKind.ClassStaticBlockDeclaration */) {
+        // Reported even with parse errors.
+        g.c.error(node, isAwaitExpression
+            ? 1854 /* Diagnostics.X_await_expression_cannot_be_used_inside_a_class_static_block */
+            : 1869 /* Diagnostics.X_await_using_statements_cannot_be_used_inside_a_class_static_block */);
+        hasError = true;
+    }
+    else if ((node.flags & 8192 /* NodeFlags.AwaitContext */) === 0) {
+        if (isInTopLevelContext(node)) {
+            if (!g.hasParseErrors) {
+                if (!isEffectiveExternalModule(g)) {
+                    g.c.addDiagnostic(diagnosticAtFirstToken(g, node, isAwaitExpression
+                        ? 304 /* Diagnostics.X_await_expressions_are_only_allowed_at_the_top_level_of_a_file_when_that_file_is_a_module_but_this_file_has_no_imports_or_exports_Consider_adding_an_empty_export_to_make_this_file_a_module */
+                        : 973 /* Diagnostics.X_await_using_statements_are_only_allowed_at_the_top_level_of_a_file_when_that_file_is_a_module_but_this_file_has_no_imports_or_exports_Consider_adding_an_empty_export_to_make_this_file_a_module */));
+                    hasError = true;
+                }
+                const support = checkTopLevelAwaitModule(g);
+                if (support === 1 /* TopLevelAwaitSupport.CommonJS */) {
+                    g.c.addDiagnostic(diagnosticAtFirstToken(g, node, 247 /* Diagnostics.The_current_file_is_a_CommonJS_module_and_cannot_use_await_at_the_top_level */));
+                    hasError = true;
+                }
+                else if (support === 2 /* TopLevelAwaitSupport.Unsupported */) {
+                    g.c.addDiagnostic(diagnosticAtFirstToken(g, node, isAwaitExpression
+                        ? 307 /* Diagnostics.Top_level_await_expressions_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_node16_node18_node20_nodenext_or_preserve_and_the_target_option_is_set_to_es2017_or_higher */
+                        : 974 /* Diagnostics.Top_level_await_using_statements_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_node16_node18_node20_nodenext_or_preserve_and_the_target_option_is_set_to_es2017_or_higher */));
+                    hasError = true;
+                }
+            }
+        }
+        else if (!g.hasParseErrors) {
+            // `await` in a function that isn't async.
+            const diagnostic = diagnosticAtFirstToken(g, node, isAwaitExpression
+                ? 246 /* Diagnostics.X_await_expressions_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules */
+                : 972 /* Diagnostics.X_await_using_statements_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules */);
+            if (container !== undefined &&
+                container.kind !== 177 /* SyntaxKind.Constructor */ &&
+                !hasSyntacticModifier(container, 1024 /* ModifierFlags.Async */))
+                addRelated(diagnostic, container, 290 /* Diagnostics.Did_you_mean_to_mark_this_function_as_async */);
+            g.c.addDiagnostic(diagnostic);
+            hasError = true;
+        }
+    }
+    if (isAwaitExpression && isInParameterInitializerBeforeContainingFunction(node)) {
+        // Reported even with parse errors.
+        g.c.error(node, 683 /* Diagnostics.X_await_expressions_cannot_be_used_in_a_parameter_initializer */);
+        hasError = true;
+    }
+    return hasError;
+}
+function checkGrammarYieldExpression(g, node) {
+    let hasError = false;
+    if ((node.flags & 2048 /* NodeFlags.YieldContext */) === 0) {
+        grammarErrorOnFirstToken(g, node, 120 /* Diagnostics.A_yield_expression_is_only_allowed_in_a_generator_body */);
+        hasError = true;
+    }
+    if (isInParameterInitializerBeforeContainingFunction(node)) {
+        g.c.error(node, 682 /* Diagnostics.X_yield_expressions_cannot_be_used_in_a_parameter_initializer */);
+        hasError = true;
+    }
+    return hasError;
+}
+function isInParameterInitializerBeforeContainingFunction(node) {
+    let inBindingInitializer = false;
+    let current = node;
+    while (current.parent !== undefined && !isFunctionLike(current.parent)) {
+        const parent = current.parent;
+        if (parent.kind === 170 /* SyntaxKind.Parameter */ && (inBindingInitializer || getInitializer(parent) === current))
+            return true;
+        if (parent.kind === 209 /* SyntaxKind.BindingElement */ && getInitializer(parent) === current)
+            inBindingInitializer = true;
+        current = parent;
+    }
+    return false;
+}
+/** A private name in an expression, which is only valid as `#x in obj`. */
+function checkGrammarPrivateIdentifierExpression(g, node) {
+    const parent = node.parent;
+    // Names of members and property accesses aren't expressions.
+    if (parent.kind === 212 /* SyntaxKind.PropertyAccessExpression */ || getName(parent) === node)
+        return false;
+    const isForIn = parent.kind === 250 /* SyntaxKind.ForInStatement */;
+    if (getContainingClass(node) === undefined)
+        return grammarErrorOnNode(g, node, 1838 /* Diagnostics.Private_identifiers_are_not_allowed_outside_class_bodies */);
+    if (isForIn)
+        return false;
+    const isLeftOfIn = parent.kind === 227 /* SyntaxKind.BinaryExpression */ &&
+        parent.left === node &&
+        parent.operatorToken.kind === 102 /* SyntaxKind.InKeyword */;
+    if (!isLeftOfIn)
+        return grammarErrorOnNode(g, node, 373 /* Diagnostics.Private_identifiers_are_only_allowed_in_class_bodies_and_may_only_be_used_as_part_of_a_class_member_declaration_property_access_or_on_the_left_hand_side_of_an_in_expression */);
+    return false;
+}
+function checkGrammarBigIntLiteral(g, node) {
+    const parent = node.parent;
+    // Like tsgo, only BigInt literals checked as expressions are reported, not property or member names.
+    if (getName(parent) === node)
+        return false;
+    const isLiteralType = parent.kind === 202 /* SyntaxKind.LiteralType */ ||
+        (parent.kind === 225 /* SyntaxKind.PrefixUnaryExpression */ && parent.parent.kind === 202 /* SyntaxKind.LiteralType */);
+    // BigInt literals are fine in types and ambient contexts.
+    return (!isLiteralType &&
+        (node.flags & 8388608 /* NodeFlags.Ambient */) === 0 &&
+        g.c.languageVersion < ScriptTarget.ES2020 &&
+        grammarErrorOnNode(g, node, 869 /* Diagnostics.BigInt_literals_are_not_available_when_targeting_lower_than_ES2020 */));
+}
+/** Reports the errors of rescanning a regular expression; spelling suggestions become related information. */
+class RegularExpressionErrorReporter extends ScannerErrorReporter {
+    g;
+    lastError = undefined;
+    constructor(g) {
+        super();
+        this.g = g;
+    }
+    onError(message, start, length, args) {
+        const lastError = this.lastError;
+        if (messageCategory(message) === 3 /* DiagnosticCategory.Message */ &&
+            lastError !== undefined &&
+            start === lastError.pos &&
+            length === lastError.end - lastError.pos) {
+            lastError.relatedInformation.push(new Diagnostic(undefined, start, start + length, message, args));
+        }
+        else if (lastError === undefined || start !== lastError.pos) {
+            const diagnostic = new Diagnostic(this.g.file.diagnosticFile(), start, start + length, message, args);
+            this.lastError = diagnostic;
+            this.g.c.addDiagnostic(diagnostic);
+        }
+    }
+}
+function checkGrammarRegularExpressionLiteral(g, node) {
+    if (g.hasParseErrors)
+        return false;
+    const scanner = g.getScanner();
+    const reporter = new RegularExpressionErrorReporter(g);
+    scanner.setOnError(reporter);
+    scanner.resetTokenState(node.pos);
+    scanner.scan();
+    scanner.reScanSlashToken(true);
+    scanner.setOnError(undefined);
+    return reporter.lastError !== undefined;
+}