tsc-ts 0.1.1 → 0.1.3

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

@@ -17,7 +17,7 @@ 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, supportsDeferredImports, supportsSourcePhaseImports, } from './options.js';
+import { ModuleKind, ScriptTarget, getEmitModuleKind, getEmitScriptTarget, supportsDeferredImports, supportsSourcePhaseImports, } from './options.js';
 import { getEmitSyntaxForModuleSpecifierExpression } from './checker-modules.js';
 import { fileExtensionIsOneOf, isExternalModuleNameRelative } from './path.js';
 import { SourceFileMetadata, getEmitModuleFormatOfFile, getImpliedNodeFormatForEmit, resolutionModeAttribute, } from './program-utilities.js';
@@ -26,11 +26,39 @@ import { typeToString } from './type-printer.js';
 import { getDeclarations } from './symbol.js';
 /** Runs the grammar checks of every node of `file`. */
 export function checkGrammarSourceFile(c, file) {
+    const diagnostics = file.grammarDiagnostics;
+    const residualNodes = file.grammarResidualNodes;
+    // A parse thread walked the file: it reported the checks that don't need the checker, and left the
+    // nodes of the checks that do (checkGrammarSourceFileInParseThread).
+    if (diagnostics !== undefined && residualNodes !== undefined) {
+        for (const diagnostic of diagnostics)
+            c.addDiagnostic(diagnostic);
+        if (residualNodes.length === 0)
+            return;
+        const g = new GrammarChecker(c, file, undefined, undefined, file.grammarAmbientReports);
+        for (const node of residualNodes)
+            g.visitNode(node);
+        return;
+    }
     const g = new GrammarChecker(c, file);
     if ((file.flags & 8388608 /* NodeFlags.Ambient */) !== 0)
         checkGrammarTopLevelElementsForRequiredDeclareModifier(g, file);
     file.forEachChild(g);
 }
+/**
+ * Runs the grammar checks of `file` in a parse thread, before the file is published: the checks that
+ * don't need the checker report now, and the nodes of those that do are kept for the checker, which
+ * runs them in the same tree order (`checkGrammarSourceFile`).
+ */
+export function checkGrammarSourceFileInParseThread(file, options, metadata) {
+    const g = new GrammarChecker(undefined, file, options, metadata);
+    if ((file.flags & 8388608 /* NodeFlags.Ambient */) !== 0)
+        checkGrammarTopLevelElementsForRequiredDeclareModifier(g, file);
+    file.forEachChild(g);
+    file.grammarDiagnostics = g.diagnostics;
+    file.grammarResidualNodes = g.residualNodes;
+    file.grammarAmbientReports = [...g.reportedAmbientStatements];
+}
 /** The grammar checker of the file of `node`, for grammar checks run while checking expressions. */
 function grammarCheckerOf(c, node) {
     const file = getSourceFileOfNode(node);
@@ -65,7 +93,10 @@ export function checkGrammarYieldOfExpression(c, node) {
 }
 /** Per-file state of the grammar walk. */
 export class GrammarChecker extends NodeVisitor {
+    /** The checker of a walk in the checker thread; undefined for a walk in a parse thread. */
     c;
+    compilerOptions;
+    languageVersion;
     file;
     /** Grammar errors are only reported in files without parse errors. */
     hasParseErrors;
@@ -73,22 +104,95 @@ export class GrammarChecker extends NodeVisitor {
     metadata;
     legacyDecorators;
     /** Blocks and statements that already reported a statement in an ambient context. */
-    reportedAmbientStatements = new Set();
+    reportedAmbientStatements;
+    /**
+     * The IDs `reportedAmbientStatements` gained in a parse thread's walk, in the order it gained them, so
+     * that the reports of a node whose check the checker runs are undone without copying the set.
+     * Undefined in the checker thread, where no check is undone.
+     */
+    ambientReportLog;
+    /**
+     * The diagnostics of a walk in a parse thread, which has no checker, for the checker to add to its
+     * collection; undefined in the checker thread, where they are reported as they are found.
+     */
+    diagnostics;
+    /** The nodes of a parse thread's walk whose check needs the checker, in tree order. */
+    residualNodes;
+    /** Set when the check of a parse thread's walk needs the checker: the checker runs that node. */
+    needsChecker = false;
     scanner = undefined;
-    constructor(c, file) {
+    constructor(c, file, options = c.compilerOptions, metadata, 
+    /** `file.grammarAmbientReports`: what a parse thread's walk already reported. */
+    ambientReports) {
         super();
         this.c = c;
+        this.compilerOptions = options;
+        this.languageVersion = getEmitScriptTarget(options);
         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;
+        this.moduleKind = getEmitModuleKind(options);
+        this.metadata = metadata ?? c.host.getSourceFileMetadata(file) ?? new SourceFileMetadata('', '', ModuleKind.None);
+        this.legacyDecorators = options.experimentalDecorators === true;
+        this.reportedAmbientStatements = new Set(ambientReports);
+        this.ambientReportLog = c === undefined ? [] : undefined;
+        this.diagnostics = c === undefined ? [] : undefined;
+        this.residualNodes = c === undefined ? [] : undefined;
     }
     visitNode(node) {
-        if (checkGrammarNode(this, node))
+        const diagnostics = this.diagnostics;
+        if (diagnostics === undefined) {
+            if (checkGrammarNode(this, node))
+                node.forEachChild(this);
+            return false;
+        }
+        // A parse thread has no checker: a node whose check needs it is recorded for the checker, with the
+        // diagnostics and the ambient-context reports it made undone, and its children are left to the
+        // checker as well.
+        const start = diagnostics.length;
+        const reportsMark = this.ambientReportLog.length;
+        const descend = checkGrammarNode(this, node);
+        if (this.needsChecker) {
+            this.needsChecker = false;
+            diagnostics.length = start;
+            this.undoAmbientReports(reportsMark);
+            this.residualNodes.push(node);
+            return false;
+        }
+        if (descend)
             node.forEachChild(this);
         return false;
     }
+    /** Records that `id` reported a statement in an ambient context. */
+    reportAmbientStatement(id) {
+        if (this.reportedAmbientStatements.has(id))
+            return;
+        this.reportedAmbientStatements.add(id);
+        this.ambientReportLog?.push(id);
+    }
+    /** Undoes the ambient-context reports added since the log had `mark` entries. */
+    undoAmbientReports(mark) {
+        const log = this.ambientReportLog;
+        for (let i = mark; i < log.length; i++)
+            this.reportedAmbientStatements.delete(log[i]);
+        log.length = mark;
+    }
+    /** Reports an error at `node`, as `Checker.error`; returns the diagnostic. */
+    error(node, message, ...args) {
+        const c = this.c;
+        if (c !== undefined)
+            return c.error(node, message, ...args);
+        const diagnostic = createDiagnosticForNode(node, message, args);
+        this.diagnostics.push(diagnostic);
+        return diagnostic;
+    }
+    /** Reports `diagnostic`, as `Checker.addDiagnostic`. */
+    report(diagnostic) {
+        const c = this.c;
+        if (c !== undefined)
+            c.addDiagnostic(diagnostic);
+        else
+            this.diagnostics.push(diagnostic);
+    }
     /** A scanner over the file's text, for rescanning tokens. */
     getScanner() {
         let scanner = this.scanner;
@@ -96,7 +200,7 @@ export class GrammarChecker extends NodeVisitor {
             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);
+            scanner.setScriptTarget(this.languageVersion);
             this.scanner = scanner;
         }
         return scanner;
@@ -106,20 +210,20 @@ export class GrammarChecker extends NodeVisitor {
 function grammarErrorOnNode(g, node, message, ...args) {
     if (g.hasParseErrors)
         return false;
-    g.c.error(node, message, ...args);
+    g.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));
+    g.report(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));
+    g.report(new Diagnostic(g.file.diagnosticFile(), start, start + length, message, args));
     return true;
 }
 /** A diagnostic at the first token of `node`. */
@@ -400,9 +504,15 @@ function checkGrammarModifiers(g, node) {
                 return grammarErrorOnFirstToken(g, node, 160 /* Diagnostics.Decorators_are_not_valid_here */);
             }
             else if (g.legacyDecorators && (node.kind === 179 /* SyntaxKind.GetAccessor */ || node.kind === 180 /* 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 */);
+                const c = g.c;
+                // Which accessor comes first is a symbol question; a parse thread leaves the node to the checker.
+                if (c === undefined)
+                    g.needsChecker = true;
+                else {
+                    const first = getFirstAccessorOfPair(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)
@@ -410,7 +520,7 @@ function checkGrammarModifiers(g, node) {
             if (hasLeadingDecorators && (flags & 98303 /* ModifierFlags.Modifier */) !== 0) {
                 if (g.hasParseErrors)
                     return false;
-                const diagnostic = g.c.error(modifier, 1787 /* Diagnostics.Decorators_may_not_appear_after_export_or_export_default_if_they_also_appear_before_export */);
+                const diagnostic = g.error(modifier, 1787 /* Diagnostics.Decorators_may_not_appear_after_export_or_export_default_if_they_also_appear_before_export */);
                 addRelated(diagnostic, firstDecorator, 399 /* Diagnostics.Decorator_used_before_export_here */);
                 return true;
             }
@@ -532,7 +642,7 @@ function checkGrammarModifiers(g, node) {
                 flags |= 8 /* ModifierFlags.Readonly */;
                 break;
             case 94 /* SyntaxKind.ExportKeyword */:
-                if (g.c.compilerOptions.verbatimModuleSyntax === true &&
+                if (g.compilerOptions.verbatimModuleSyntax === true &&
                     (node.flags & 8388608 /* NodeFlags.Ambient */) === 0 &&
                     node.kind !== 267 /* SyntaxKind.TypeAliasDeclaration */ &&
                     node.kind !== 266 /* SyntaxKind.InterfaceDeclaration */ &&
@@ -880,7 +990,7 @@ function checkGrammarDecorator(g, decorator) {
     }
     if (errorNode === undefined)
         return false;
-    const diagnostic = g.c.error(decorator.expression, 410 /* Diagnostics.Expression_must_be_enclosed_in_parentheses_to_be_used_as_a_decorator */);
+    const diagnostic = g.error(decorator.expression, 410 /* Diagnostics.Expression_must_be_enclosed_in_parentheses_to_be_used_as_a_decorator */);
     addRelated(diagnostic, errorNode, 411 /* Diagnostics.Invalid_syntax_in_decorator */);
     return true;
 }
@@ -931,7 +1041,7 @@ function checkGrammarParameterList(g, parameters) {
     return false;
 }
 function checkGrammarForUseStrictSimpleParameterList(g, node) {
-    if (g.c.languageVersion < ScriptTarget.ES2016)
+    if (g.languageVersion < ScriptTarget.ES2016)
         return false;
     const body = getBody(node);
     if (body === undefined || body.kind !== 243 /* SyntaxKind.Block */)
@@ -948,10 +1058,10 @@ function checkGrammarForUseStrictSimpleParameterList(g, node) {
     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 */);
+        const diagnostic = g.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 */);
+    const diagnostic = g.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 */ : 1368 /* Diagnostics.X_and_here */);
     return true;
@@ -1034,10 +1144,16 @@ function checkGrammarIndexSignatureParameters(g, node) {
         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))
+    const c = g.c;
+    if (c === undefined) {
+        // The parameter's type decides; a parse thread leaves the node to the checker.
+        g.needsChecker = true;
+        return false;
+    }
+    const t = getTypeFromTypeNode(c, parameter.type);
+    if (someTypeHasFlags(t, 19456 /* TypeFlags.StringOrNumberLiteralOrUnique */) || isGenericType(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))
+    if (!everyTypeIsValidIndexKey(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 */);
@@ -1193,7 +1309,7 @@ function checkGrammarForInvalidExclamationToken(g, postfixToken, message) {
         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) {
+function isNonBindableDynamicName(g, node) {
     if (!isDynamicName(node))
         return false;
     let expression;
@@ -1203,13 +1319,19 @@ function isNonBindableDynamicName(c, node) {
         expression = node.argumentExpression;
     if (expression === undefined || !isEntityNameExpression(expression, false))
         return true;
+    const c = g.c;
+    if (c === undefined) {
+        // The name's type decides; a parse thread leaves the node to the checker.
+        g.needsChecker = true;
+        return false;
+    }
     const t = node.kind === 169 /* SyntaxKind.ComputedPropertyName */
         ? checkComputedPropertyName(c, node)
         : checkExpressionCached(c, expression);
     return !isTypeUsableAsPropertyName(t);
 }
 function checkGrammarForInvalidDynamicName(g, node, message) {
-    if (!isNonBindableDynamicName(g.c, node))
+    if (!isNonBindableDynamicName(g, node))
         return false;
     const expression = node instanceof ElementAccessExpression ? skipParentheses(node.argumentExpression) : getExpression(node);
     return !isEntityNameExpression(expression, false) && grammarErrorOnNode(g, node, message);
@@ -1225,11 +1347,11 @@ function checkGrammarMethodDeclaration(g, 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 */);
+            g.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, 1858 /* Diagnostics.Private_identifiers_are_not_allowed_outside_class_bodies */);
+        g.error(node, 1858 /* Diagnostics.Private_identifiers_are_not_allowed_outside_class_bodies */);
 }
 function checkGrammarMethod(g, node) {
     if (checkGrammarFunctionLikeDeclaration(g, node))
@@ -1380,7 +1502,7 @@ function checkAmbientInitializer(g, node) {
     if (initializer === undefined)
         return false;
     const isInvalidInitializer = !(isInitializerStringOrNumberLiteralExpression(initializer) ||
-        isInitializerSimpleLiteralEnumReference(g.c, initializer) ||
+        isInitializerSimpleLiteralEnumReference(g, initializer) ||
         initializer.kind === 111 /* SyntaxKind.TrueKeyword */ ||
         initializer.kind === 96 /* SyntaxKind.FalseKeyword */ ||
         isInitializerBigIntLiteralExpression(initializer));
@@ -1420,14 +1542,25 @@ function isInitializerBigIntLiteralExpression(expression) {
     const unary = expression;
     return unary.operator === 40 /* SyntaxKind.MinusToken */ && unary.operand.kind === 9 /* SyntaxKind.BigIntLiteral */;
 }
-function isInitializerSimpleLiteralEnumReference(c, expression) {
+function isInitializerSimpleLiteralEnumReference(g, expression) {
+    let accessesEnum;
     if (expression.kind === 213 /* 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;
+        accessesEnum = true;
+    else if (expression instanceof ElementAccessExpression)
+        accessesEnum =
+            isInitializerStringOrNumberLiteralExpression(expression.argumentExpression) &&
+                isEntityNameExpression(expression.expression, false);
+    else
+        return false;
+    if (!accessesEnum)
+        return false;
+    // Whether the reference is to an enum is a type question.
+    const c = g.c;
+    if (c === undefined) {
+        g.needsChecker = true;
+        return false;
+    }
+    return (checkExpressionCached(c, expression).flags & 98304 /* TypeFlags.EnumLike */) !== 0;
 }
 // ---- Statements
 function checkGrammarStatementInAmbientContext(g, node) {
@@ -1438,7 +1571,7 @@ function checkGrammarStatementInAmbientContext(g, 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);
+            g.reportAmbientStatement(id);
         return reported;
     }
     // Report once per block; statements nested in other statements are covered by their parent.
@@ -1449,7 +1582,7 @@ function checkGrammarStatementInAmbientContext(g, node) {
         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);
+                g.reportAmbientStatement(parentId);
             return reported;
         }
     }
@@ -1477,7 +1610,7 @@ function checkGrammarForDisallowedBlockScopedVariableStatement(g, node) {
         keyword = 'using';
     else
         keyword = 'await using';
-    g.c.error(node, 116 /* Diagnostics.X_0_declarations_can_only_be_declared_inside_a_block */, keyword);
+    g.error(node, 116 /* Diagnostics.X_0_declarations_can_only_be_declared_inside_a_block */, keyword);
 }
 function containerAllowsBlockScopedVariable(parent) {
     switch (parent.kind) {
@@ -1627,12 +1760,12 @@ function checkGrammarForInOrForOfStatementWorker(g, node) {
         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 */, []));
+                    g.report(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 */, []));
+                    g.report(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 */, []));
+                    g.report(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) {
@@ -1641,7 +1774,7 @@ function checkGrammarForInOrForOfStatementWorker(g, node) {
             const containingFunction = getContainingFunction(node);
             if (containingFunction !== undefined && containingFunction.kind !== 178 /* SyntaxKind.Constructor */)
                 addRelated(diagnostic, containingFunction, 290 /* Diagnostics.Did_you_mean_to_mark_this_function_as_async */);
-            g.c.addDiagnostic(diagnostic);
+            g.report(diagnostic);
             return true;
         }
     }
@@ -1690,7 +1823,7 @@ function checkTopLevelAwaitModule(g) {
         moduleKind !== ModuleKind.Preserve &&
         moduleKind !== ModuleKind.System)
         return 2 /* TopLevelAwaitSupport.Unsupported */;
-    return g.c.languageVersion >= ScriptTarget.ES2017 ? 0 /* TopLevelAwaitSupport.Supported */ : 2 /* TopLevelAwaitSupport.Unsupported */;
+    return g.languageVersion >= ScriptTarget.ES2017 ? 0 /* TopLevelAwaitSupport.Supported */ : 2 /* TopLevelAwaitSupport.Unsupported */;
 }
 function checkGrammarBreakOrContinueStatement(g, node) {
     const targetLabel = getLabel(node);
@@ -1789,7 +1922,13 @@ function checkGrammarCatchClause(g, node) {
         return;
     const typeNode = declaration.type;
     if (typeNode !== undefined) {
-        const t = getTypeFromTypeNode(g.c, typeNode);
+        // The annotation's type decides; a parse thread leaves the node to the checker.
+        const c = g.c;
+        if (c === undefined) {
+            g.needsChecker = true;
+            return;
+        }
+        const t = getTypeFromTypeNode(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 */);
     }
@@ -1900,13 +2039,13 @@ function checkExternalImportOrExportDeclaration(g, node) {
     if (moduleName === undefined || moduleName.pos === moduleName.end)
         return false;
     if (moduleName.kind !== 10 /* SyntaxKind.StringLiteral */) {
-        g.c.error(moduleName, 107 /* Diagnostics.String_literal_expected */);
+        g.error(moduleName, 107 /* Diagnostics.String_literal_expected */);
         return false;
     }
     const parent = node.parent;
     const inAmbientExternalModule = parent.kind === 270 /* SyntaxKind.ModuleBlock */ && isAmbientModule(parent.parent);
     if (parent.kind !== 308 /* SyntaxKind.SourceFile */ && !inAmbientExternalModule) {
-        g.c.error(moduleName, node.kind === 280 /* SyntaxKind.ExportDeclaration */
+        g.error(moduleName, node.kind === 280 /* 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;
@@ -1915,7 +2054,7 @@ function checkExternalImportOrExportDeclaration(g, node) {
         isExternalModuleNameRelative(moduleName.text) &&
         !isModuleAugmentationExternal(parent.parent)) {
         // Module augmentations report relative names when checking the augmentation.
-        g.c.error(node, 614 /* Diagnostics.Import_or_export_declaration_in_an_ambient_module_declaration_cannot_reference_module_through_relative_module_name */);
+        g.error(node, 614 /* Diagnostics.Import_or_export_declaration_in_an_ambient_module_declaration_cannot_reference_module_through_relative_module_name */);
         return false;
     }
     if (node.kind === 273 /* SyntaxKind.ImportEqualsDeclaration */)
@@ -1930,7 +2069,7 @@ function checkGrammarImportAttributeValues(g, node) {
         const value = attribute.value;
         if (value.kind !== 10 /* SyntaxKind.StringLiteral */) {
             hasError = true;
-            g.c.error(value, 985 /* Diagnostics.Import_attribute_values_must_be_string_literal_expressions */);
+            g.error(value, 985 /* Diagnostics.Import_attribute_values_must_be_string_literal_expressions */);
         }
     }
     return hasError;
@@ -1982,8 +2121,14 @@ function checkGrammarImportClause(g, node) {
         if (!supportsSourcePhaseImports(g.moduleKind))
             return grammarErrorOnNode(g, node, 1948 /* Diagnostics.Source_phase_imports_are_only_supported_when_the_module_option_is_set_to_esnext_nodenext_or_preserve */);
         const moduleSpecifier = node.parent.moduleSpecifier;
-        if (getEmitSyntaxForModuleSpecifierExpression(g.c, moduleSpecifier) === ModuleKind.CommonJS)
-            return grammarErrorOnNode(g, node, 1950 /* Diagnostics.Source_phase_imports_are_not_allowed_on_statements_that_compile_to_CommonJS_require_calls */);
+        const c = g.c;
+        // The specifier's emit syntax comes from the module resolution; a parse thread leaves it to the checker.
+        if (c !== undefined) {
+            if (getEmitSyntaxForModuleSpecifierExpression(c, moduleSpecifier) === ModuleKind.CommonJS)
+                return grammarErrorOnNode(g, node, 1950 /* Diagnostics.Source_phase_imports_are_not_allowed_on_statements_that_compile_to_CommonJS_require_calls */);
+        }
+        else
+            g.needsChecker = true;
     }
     return false;
 }
@@ -2005,9 +2150,15 @@ function checkGrammarImportEqualsDeclaration(g, node) {
     const isExternal = node.moduleReference.kind === 285 /* 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 */);
+            const c = g.c;
+            // Whether the alias resolves is a symbol question; a parse thread leaves the node to the checker.
+            if (c === undefined)
+                g.needsChecker = true;
+            else {
+                const symbol = getSymbolOfDeclaration(c, node);
+                if (symbol !== undefined && resolveAlias(c, symbol) !== c.unknownSymbol)
+                    grammarErrorOnNode(g, node, 318 /* Diagnostics.An_import_alias_cannot_use_import_type */);
+            }
         }
         return;
     }
@@ -2042,7 +2193,7 @@ function checkGrammarExportDeclaration(g, node) {
             !hasModuleSpecifier &&
             (node.flags & 8388608 /* NodeFlags.Ambient */) !== 0;
         if (parent.kind !== 308 /* SyntaxKind.SourceFile */ && !inAmbientExternalModule && !inAmbientNamespaceDeclaration)
-            g.c.error(node, 150 /* Diagnostics.Export_declarations_are_not_permitted_in_a_namespace */);
+            g.error(node, 150 /* Diagnostics.Export_declarations_are_not_permitted_in_a_namespace */);
     }
     checkGrammarImportAttributes(g, node);
 }
@@ -2064,7 +2215,7 @@ function checkGrammarExportAssignment(g, node) {
     const parent = node.parent;
     const container = parent.kind === 308 /* SyntaxKind.SourceFile */ ? parent : parent.parent;
     if (container.kind === 269 /* SyntaxKind.ModuleDeclaration */ && !isAmbientModule(container)) {
-        g.c.error(node, isExportEquals
+        g.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;
@@ -2087,7 +2238,7 @@ function checkGrammarExportAssignment(g, node) {
     return true;
 }
 function getEmitModuleFormat(g) {
-    return getEmitModuleFormatOfFile(g.file.fileName, g.c.compilerOptions, g.metadata);
+    return getEmitModuleFormatOfFile(g.file.fileName, g.compilerOptions, g.metadata);
 }
 function isEffectiveExternalModule(g) {
     if (isExternalModule(g.file))
@@ -2162,13 +2313,19 @@ function checkGrammarTupleType(g, node) {
     let seenOptionalElement = false;
     let seenRestElement = false;
     for (const element of node.elements.nodes) {
-        let flags = getTupleElementFlags(g.c, element);
+        let flags = getTupleElementFlags(element);
         if ((flags & 8 /* ElementFlags.Variadic */) !== 0) {
-            const t = getTypeFromTypeNode(g.c, getType(element));
+            const c = g.c;
+            // The element type decides whether a variadic element is a rest element.
+            if (c === undefined) {
+                g.needsChecker = true;
+                return;
+            }
+            const t = getTypeFromTypeNode(c, getType(element));
             // `checkTupleType` reports non-array rest types and stops.
-            if (!isArrayLikeType(g.c, t))
+            if (!isArrayLikeType(c, t))
                 break;
-            if (isArrayType(g.c, t) || (isTupleType(t) && (tupleTargetOf(t).combinedFlags & 4 /* ElementFlags.Rest */) !== 0))
+            if (isArrayType(c, t) || (isTupleType(t) && (tupleTargetOf(t).combinedFlags & 4 /* ElementFlags.Rest */) !== 0))
                 flags |= 4 /* ElementFlags.Rest */;
         }
         if ((flags & 4 /* ElementFlags.Rest */) !== 0) {
@@ -2210,12 +2367,18 @@ function checkGrammarJSDocTypeInTypeScript(g, node) {
     const isNullable = node.kind === 312 /* 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 */);
+    const c = g.c;
+    // The error names the type's printed form; a parse thread leaves the node to the checker.
+    if (c === undefined) {
+        g.needsChecker = true;
+        return;
+    }
+    let t = getTypeFromTypeNode(c, typeNode);
+    if (isNullable && t !== c.neverType && t !== c.voidType)
+        t = getNullableType(c, t, postfix ? 4 /* TypeFlags.Undefined */ : 12 /* TypeFlags.Nullable */);
     grammarErrorOnNode(g, node, postfix
         ? 1842 /* Diagnostics.X_0_at_the_end_of_a_type_is_not_valid_TypeScript_syntax_Did_you_mean_to_write_1 */
-        : 1843 /* 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));
+        : 1843 /* Diagnostics.X_0_at_the_start_of_a_type_is_not_valid_TypeScript_syntax_Did_you_mean_to_write_1 */, isNullable ? '?' : '!', typeToString(c, t));
 }
 /** The `resolution-mode` of import type attributes, as tsgo's `GetResolutionModeOverride`. */
 function getResolutionModeOverride(g, node, reportErrors) {
@@ -2321,7 +2484,7 @@ function checkGrammarObjectLiteralExpression(g, node, inDestructuring) {
                 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, 452 /* Diagnostics.A_bigint_literal_cannot_be_used_as_a_property_name */, []));
+                    g.report(createDiagnosticForNode(name, 452 /* Diagnostics.A_bigint_literal_cannot_be_used_as_a_property_name */, []));
                 currentKind = 4 /* DeclarationMeaning.PropertyAssignment */;
                 break;
             }
@@ -2337,6 +2500,7 @@ function checkGrammarObjectLiteralExpression(g, node, inDestructuring) {
         }
         if (inDestructuring)
             continue;
+        // Object literals are checked with the checker, when the expression is checked.
         const effectiveName = getEffectivePropertyNameForPropertyNameNode(g.c, name);
         if (effectiveName === undefined || seen === undefined)
             continue;
@@ -2405,7 +2569,7 @@ function checkGrammarCallExpression(g, node) {
 }
 function checkGrammarImportCallExpression(g, node) {
     const moduleKind = g.moduleKind;
-    if (g.c.compilerOptions.verbatimModuleSyntax === true && moduleKind === ModuleKind.CommonJS)
+    if (g.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 */);
@@ -2475,7 +2639,7 @@ function checkGrammarAwaitOrAwaitUsing(g, node) {
     const container = getContainingFunctionOrClassStaticBlock(node);
     if (container !== undefined && container.kind === 177 /* SyntaxKind.ClassStaticBlockDeclaration */) {
         // Reported even with parse errors.
-        g.c.error(node, isAwaitExpression
+        g.error(node, isAwaitExpression
             ? 1874 /* Diagnostics.X_await_expression_cannot_be_used_inside_a_class_static_block */
             : 1889 /* Diagnostics.X_await_using_statements_cannot_be_used_inside_a_class_static_block */);
         hasError = true;
@@ -2484,18 +2648,18 @@ function checkGrammarAwaitOrAwaitUsing(g, node) {
         if (isInTopLevelContext(node)) {
             if (!g.hasParseErrors) {
                 if (!isEffectiveExternalModule(g)) {
-                    g.c.addDiagnostic(diagnosticAtFirstToken(g, node, isAwaitExpression
+                    g.report(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 */
                         : 980 /* 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 */));
+                    g.report(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
+                    g.report(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 */
                         : 981 /* 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;
@@ -2511,13 +2675,13 @@ function checkGrammarAwaitOrAwaitUsing(g, node) {
                 container.kind !== 178 /* 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);
+            g.report(diagnostic);
             hasError = true;
         }
     }
     if (isAwaitExpression && isInParameterInitializerBeforeContainingFunction(node)) {
         // Reported even with parse errors.
-        g.c.error(node, 690 /* Diagnostics.X_await_expressions_cannot_be_used_in_a_parameter_initializer */);
+        g.error(node, 690 /* Diagnostics.X_await_expressions_cannot_be_used_in_a_parameter_initializer */);
         hasError = true;
     }
     return hasError;
@@ -2529,7 +2693,7 @@ function checkGrammarYieldExpression(g, node) {
         hasError = true;
     }
     if (isInParameterInitializerBeforeContainingFunction(node)) {
-        g.c.error(node, 689 /* Diagnostics.X_yield_expressions_cannot_be_used_in_a_parameter_initializer */);
+        g.error(node, 689 /* Diagnostics.X_yield_expressions_cannot_be_used_in_a_parameter_initializer */);
         hasError = true;
     }
     return hasError;
@@ -2579,7 +2743,7 @@ function checkGrammarBigIntLiteral(g, node) {
     // BigInt literals are fine in types and ambient contexts.
     return (!isLiteralType &&
         (node.flags & 8388608 /* NodeFlags.Ambient */) === 0 &&
-        g.c.languageVersion < ScriptTarget.ES2020 &&
+        g.languageVersion < ScriptTarget.ES2020 &&
         grammarErrorOnNode(g, node, 876 /* Diagnostics.BigInt_literals_are_not_available_when_targeting_lower_than_ES2020 */));
 }
 /** Reports the errors of rescanning a regular expression; spelling suggestions become related information. */
@@ -2601,7 +2765,7 @@ class RegularExpressionErrorReporter extends ScannerErrorReporter {
         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);
+            this.g.report(diagnostic);
         }
     }
 }