typescript 4.7.0-dev.20220323 → 4.7.0-dev.20220327

package/lib/tsc.js

@@ -69,7 +69,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 var ts;
 (function (ts) {
     ts.versionMajorMinor = "4.7";
-    ts.version = ts.versionMajorMinor + ".0-dev.20220323";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220327";
     var NativeCollections;
     (function (NativeCollections) {
         var globals = typeof globalThis !== "undefined" ? globalThis :
@@ -5592,6 +5592,7 @@ var ts;
         Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1: diag(2205, ts.DiagnosticCategory.Error, "Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1_2205", "Construct signatures with no arguments have incompatible return types '{0}' and '{1}'.", undefined, true),
         The_type_modifier_cannot_be_used_on_a_named_import_when_import_type_is_used_on_its_import_statement: diag(2206, ts.DiagnosticCategory.Error, "The_type_modifier_cannot_be_used_on_a_named_import_when_import_type_is_used_on_its_import_statement_2206", "The 'type' modifier cannot be used on a named import when 'import type' is used on its import statement."),
         The_type_modifier_cannot_be_used_on_a_named_export_when_export_type_is_used_on_its_export_statement: diag(2207, ts.DiagnosticCategory.Error, "The_type_modifier_cannot_be_used_on_a_named_export_when_export_type_is_used_on_its_export_statement_2207", "The 'type' modifier cannot be used on a named export when 'export type' is used on its export statement."),
+        This_type_parameter_probably_needs_an_extends_object_constraint: diag(2208, ts.DiagnosticCategory.Error, "This_type_parameter_probably_needs_an_extends_object_constraint_2208", "This type parameter probably needs an `extends object` constraint."),
         Duplicate_identifier_0: diag(2300, ts.DiagnosticCategory.Error, "Duplicate_identifier_0_2300", "Duplicate identifier '{0}'."),
         Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor: diag(2301, ts.DiagnosticCategory.Error, "Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor_2301", "Initializer of instance member variable '{0}' cannot reference identifier '{1}' declared in the constructor."),
         Static_members_cannot_reference_class_type_parameters: diag(2302, ts.DiagnosticCategory.Error, "Static_members_cannot_reference_class_type_parameters_2302", "Static members cannot reference class type parameters."),
@@ -36315,15 +36316,18 @@ var ts;
                 var saveExceptionTarget = currentExceptionTarget;
                 var saveActiveLabelList = activeLabelList;
                 var saveHasExplicitReturn = hasExplicitReturn;
-                var isIIFE = containerFlags & 16 && !ts.hasSyntacticModifier(node, 256) &&
-                    !node.asteriskToken && !!ts.getImmediatelyInvokedFunctionExpression(node);
-                if (!isIIFE) {
+                var isImmediatelyInvoked = (containerFlags & 16 &&
+                    !ts.hasSyntacticModifier(node, 256) &&
+                    !node.asteriskToken &&
+                    !!ts.getImmediatelyInvokedFunctionExpression(node)) ||
+                    node.kind === 170;
+                if (!isImmediatelyInvoked) {
                     currentFlow = initFlowNode({ flags: 2 });
                     if (containerFlags & (16 | 128)) {
                         currentFlow.node = node;
                     }
                 }
-                currentReturnTarget = isIIFE || node.kind === 171 || node.kind === 170 || (ts.isInJSFile(node) && (node.kind === 256 || node.kind === 213)) ? createBranchLabel() : undefined;
+                currentReturnTarget = isImmediatelyInvoked || node.kind === 171 || (ts.isInJSFile(node) && (node.kind === 256 || node.kind === 213)) ? createBranchLabel() : undefined;
                 currentExceptionTarget = undefined;
                 currentBreakTarget = undefined;
                 currentContinueTarget = undefined;
@@ -36348,7 +36352,7 @@ var ts;
                         node.returnFlowNode = currentFlow;
                     }
                 }
-                if (!isIIFE) {
+                if (!isImmediatelyInvoked) {
                     currentFlow = saveCurrentFlow;
                 }
                 currentBreakTarget = saveBreakTarget;
@@ -38865,7 +38869,7 @@ var ts;
             (preserveConstEnums && moduleState === 2);
     }
     ts.isInstantiatedModule = isInstantiatedModule;
-    function createTypeChecker(host, produceDiagnostics) {
+    function createTypeChecker(host) {
         var getPackagesMap = ts.memoize(function () {
             var map = new ts.Map();
             host.getSourceFiles().forEach(function (sf) {
@@ -38878,6 +38882,10 @@ var ts;
             });
             return map;
         });
+        var deferredDiagnosticsCallbacks = [];
+        var addLazyDiagnostic = function (arg) {
+            deferredDiagnosticsCallbacks.push(arg);
+        };
         var cancellationToken;
         var requestedExternalEmitHelpers;
         var externalHelpersModule;
@@ -39220,7 +39228,7 @@ var ts;
                 var diagnostics;
                 try {
                     cancellationToken = ct;
-                    checkSourceFile(file);
+                    checkSourceFileWithEagerDiagnostics(file);
                     ts.Debug.assert(!!(getNodeLinks(file).flags & 1));
                     diagnostics = ts.addRange(diagnostics, suggestionDiagnostics.getDiagnostics(file.fileName));
                     checkUnusedIdentifiers(getPotentiallyUnusedIdentifiers(file), function (containingNode, kind, diag) {
@@ -40374,91 +40382,95 @@ var ts;
                 }
             }
             if (!result) {
-                if (nameNotFoundMessage && produceDiagnostics) {
-                    if (!errorLocation ||
-                        !checkAndReportErrorForMissingPrefix(errorLocation, name, nameArg) &&
-                            !checkAndReportErrorForExtendingInterface(errorLocation) &&
-                            !checkAndReportErrorForUsingTypeAsNamespace(errorLocation, name, meaning) &&
-                            !checkAndReportErrorForExportingPrimitiveType(errorLocation, name) &&
-                            !checkAndReportErrorForUsingTypeAsValue(errorLocation, name, meaning) &&
-                            !checkAndReportErrorForUsingNamespaceModuleAsValue(errorLocation, name, meaning) &&
-                            !checkAndReportErrorForUsingValueAsType(errorLocation, name, meaning)) {
-                        var suggestion = void 0;
-                        if (getSpellingSuggestions && suggestionCount < maximumSuggestionCount) {
-                            suggestion = getSuggestedSymbolForNonexistentSymbol(originalLocation, name, meaning);
-                            var isGlobalScopeAugmentationDeclaration = (suggestion === null || suggestion === void 0 ? void 0 : suggestion.valueDeclaration) && ts.isAmbientModule(suggestion.valueDeclaration) && ts.isGlobalScopeAugmentation(suggestion.valueDeclaration);
-                            if (isGlobalScopeAugmentationDeclaration) {
-                                suggestion = undefined;
-                            }
-                            if (suggestion) {
-                                var suggestionName = symbolToString(suggestion);
-                                var isUncheckedJS = isUncheckedJSSuggestion(originalLocation, suggestion, false);
-                                var message = meaning === 1920 || nameArg && typeof nameArg !== "string" && ts.nodeIsSynthesized(nameArg) ? ts.Diagnostics.Cannot_find_namespace_0_Did_you_mean_1
-                                    : isUncheckedJS ? ts.Diagnostics.Could_not_find_name_0_Did_you_mean_1
-                                        : ts.Diagnostics.Cannot_find_name_0_Did_you_mean_1;
-                                var diagnostic = createError(errorLocation, message, diagnosticName(nameArg), suggestionName);
-                                addErrorOrSuggestion(!isUncheckedJS, diagnostic);
-                                if (suggestion.valueDeclaration) {
-                                    ts.addRelatedInfo(diagnostic, ts.createDiagnosticForNode(suggestion.valueDeclaration, ts.Diagnostics._0_is_declared_here, suggestionName));
+                if (nameNotFoundMessage) {
+                    addLazyDiagnostic(function () {
+                        if (!errorLocation ||
+                            !checkAndReportErrorForMissingPrefix(errorLocation, name, nameArg) &&
+                                !checkAndReportErrorForExtendingInterface(errorLocation) &&
+                                !checkAndReportErrorForUsingTypeAsNamespace(errorLocation, name, meaning) &&
+                                !checkAndReportErrorForExportingPrimitiveType(errorLocation, name) &&
+                                !checkAndReportErrorForUsingTypeAsValue(errorLocation, name, meaning) &&
+                                !checkAndReportErrorForUsingNamespaceModuleAsValue(errorLocation, name, meaning) &&
+                                !checkAndReportErrorForUsingValueAsType(errorLocation, name, meaning)) {
+                            var suggestion = void 0;
+                            if (getSpellingSuggestions && suggestionCount < maximumSuggestionCount) {
+                                suggestion = getSuggestedSymbolForNonexistentSymbol(originalLocation, name, meaning);
+                                var isGlobalScopeAugmentationDeclaration = (suggestion === null || suggestion === void 0 ? void 0 : suggestion.valueDeclaration) && ts.isAmbientModule(suggestion.valueDeclaration) && ts.isGlobalScopeAugmentation(suggestion.valueDeclaration);
+                                if (isGlobalScopeAugmentationDeclaration) {
+                                    suggestion = undefined;
                                 }
-                            }
-                        }
-                        if (!suggestion) {
-                            if (nameArg) {
-                                var lib = getSuggestedLibForNonExistentName(nameArg);
-                                if (lib) {
-                                    error(errorLocation, nameNotFoundMessage, diagnosticName(nameArg), lib);
+                                if (suggestion) {
+                                    var suggestionName = symbolToString(suggestion);
+                                    var isUncheckedJS = isUncheckedJSSuggestion(originalLocation, suggestion, false);
+                                    var message = meaning === 1920 || nameArg && typeof nameArg !== "string" && ts.nodeIsSynthesized(nameArg) ? ts.Diagnostics.Cannot_find_namespace_0_Did_you_mean_1
+                                        : isUncheckedJS ? ts.Diagnostics.Could_not_find_name_0_Did_you_mean_1
+                                            : ts.Diagnostics.Cannot_find_name_0_Did_you_mean_1;
+                                    var diagnostic = createError(errorLocation, message, diagnosticName(nameArg), suggestionName);
+                                    addErrorOrSuggestion(!isUncheckedJS, diagnostic);
+                                    if (suggestion.valueDeclaration) {
+                                        ts.addRelatedInfo(diagnostic, ts.createDiagnosticForNode(suggestion.valueDeclaration, ts.Diagnostics._0_is_declared_here, suggestionName));
+                                    }
                                 }
-                                else {
-                                    error(errorLocation, nameNotFoundMessage, diagnosticName(nameArg));
+                            }
+                            if (!suggestion) {
+                                if (nameArg) {
+                                    var lib = getSuggestedLibForNonExistentName(nameArg);
+                                    if (lib) {
+                                        error(errorLocation, nameNotFoundMessage, diagnosticName(nameArg), lib);
+                                    }
+                                    else {
+                                        error(errorLocation, nameNotFoundMessage, diagnosticName(nameArg));
+                                    }
                                 }
                             }
+                            suggestionCount++;
                         }
-                        suggestionCount++;
-                    }
+                    });
                 }
                 return undefined;
             }
-            if (nameNotFoundMessage && produceDiagnostics) {
-                if (propertyWithInvalidInitializer && !(ts.getEmitScriptTarget(compilerOptions) === 99 && useDefineForClassFields)) {
-                    var propertyName = propertyWithInvalidInitializer.name;
-                    error(errorLocation, ts.Diagnostics.Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor, ts.declarationNameToString(propertyName), diagnosticName(nameArg));
-                    return undefined;
-                }
-                if (errorLocation &&
-                    (meaning & 2 ||
-                        ((meaning & 32 || meaning & 384) && (meaning & 111551) === 111551))) {
-                    var exportOrLocalSymbol = getExportSymbolOfValueSymbolIfExported(result);
-                    if (exportOrLocalSymbol.flags & 2 || exportOrLocalSymbol.flags & 32 || exportOrLocalSymbol.flags & 384) {
-                        checkResolvedBlockScopedVariable(exportOrLocalSymbol, errorLocation);
-                    }
-                }
-                if (result && isInExternalModule && (meaning & 111551) === 111551 && !(originalLocation.flags & 4194304)) {
-                    var merged = getMergedSymbol(result);
-                    if (ts.length(merged.declarations) && ts.every(merged.declarations, function (d) { return ts.isNamespaceExportDeclaration(d) || ts.isSourceFile(d) && !!d.symbol.globalExports; })) {
-                        errorOrSuggestion(!compilerOptions.allowUmdGlobalAccess, errorLocation, ts.Diagnostics._0_refers_to_a_UMD_global_but_the_current_file_is_a_module_Consider_adding_an_import_instead, ts.unescapeLeadingUnderscores(name));
+            if (propertyWithInvalidInitializer && !(ts.getEmitScriptTarget(compilerOptions) === 99 && useDefineForClassFields)) {
+                var propertyName = propertyWithInvalidInitializer.name;
+                error(errorLocation, ts.Diagnostics.Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor, ts.declarationNameToString(propertyName), diagnosticName(nameArg));
+                return undefined;
+            }
+            if (nameNotFoundMessage) {
+                addLazyDiagnostic(function () {
+                    if (errorLocation &&
+                        (meaning & 2 ||
+                            ((meaning & 32 || meaning & 384) && (meaning & 111551) === 111551))) {
+                        var exportOrLocalSymbol = getExportSymbolOfValueSymbolIfExported(result);
+                        if (exportOrLocalSymbol.flags & 2 || exportOrLocalSymbol.flags & 32 || exportOrLocalSymbol.flags & 384) {
+                            checkResolvedBlockScopedVariable(exportOrLocalSymbol, errorLocation);
+                        }
                     }
-                }
-                if (result && associatedDeclarationForContainingInitializerOrBindingName && !withinDeferredContext && (meaning & 111551) === 111551) {
-                    var candidate = getMergedSymbol(getLateBoundSymbol(result));
-                    var root = ts.getRootDeclaration(associatedDeclarationForContainingInitializerOrBindingName);
-                    if (candidate === getSymbolOfNode(associatedDeclarationForContainingInitializerOrBindingName)) {
-                        error(errorLocation, ts.Diagnostics.Parameter_0_cannot_reference_itself, ts.declarationNameToString(associatedDeclarationForContainingInitializerOrBindingName.name));
+                    if (result && isInExternalModule && (meaning & 111551) === 111551 && !(originalLocation.flags & 4194304)) {
+                        var merged = getMergedSymbol(result);
+                        if (ts.length(merged.declarations) && ts.every(merged.declarations, function (d) { return ts.isNamespaceExportDeclaration(d) || ts.isSourceFile(d) && !!d.symbol.globalExports; })) {
+                            errorOrSuggestion(!compilerOptions.allowUmdGlobalAccess, errorLocation, ts.Diagnostics._0_refers_to_a_UMD_global_but_the_current_file_is_a_module_Consider_adding_an_import_instead, ts.unescapeLeadingUnderscores(name));
+                        }
                     }
-                    else if (candidate.valueDeclaration && candidate.valueDeclaration.pos > associatedDeclarationForContainingInitializerOrBindingName.pos && root.parent.locals && lookup(root.parent.locals, candidate.escapedName, meaning) === candidate) {
-                        error(errorLocation, ts.Diagnostics.Parameter_0_cannot_reference_identifier_1_declared_after_it, ts.declarationNameToString(associatedDeclarationForContainingInitializerOrBindingName.name), ts.declarationNameToString(errorLocation));
+                    if (result && associatedDeclarationForContainingInitializerOrBindingName && !withinDeferredContext && (meaning & 111551) === 111551) {
+                        var candidate = getMergedSymbol(getLateBoundSymbol(result));
+                        var root = ts.getRootDeclaration(associatedDeclarationForContainingInitializerOrBindingName);
+                        if (candidate === getSymbolOfNode(associatedDeclarationForContainingInitializerOrBindingName)) {
+                            error(errorLocation, ts.Diagnostics.Parameter_0_cannot_reference_itself, ts.declarationNameToString(associatedDeclarationForContainingInitializerOrBindingName.name));
+                        }
+                        else if (candidate.valueDeclaration && candidate.valueDeclaration.pos > associatedDeclarationForContainingInitializerOrBindingName.pos && root.parent.locals && lookup(root.parent.locals, candidate.escapedName, meaning) === candidate) {
+                            error(errorLocation, ts.Diagnostics.Parameter_0_cannot_reference_identifier_1_declared_after_it, ts.declarationNameToString(associatedDeclarationForContainingInitializerOrBindingName.name), ts.declarationNameToString(errorLocation));
+                        }
                     }
-                }
-                if (result && errorLocation && meaning & 111551 && result.flags & 2097152 && !(result.flags & 111551) && !ts.isValidTypeOnlyAliasUseSite(errorLocation)) {
-                    var typeOnlyDeclaration = getTypeOnlyAliasDeclaration(result);
-                    if (typeOnlyDeclaration) {
-                        var message = typeOnlyDeclaration.kind === 275
-                            ? ts.Diagnostics._0_cannot_be_used_as_a_value_because_it_was_exported_using_export_type
-                            : ts.Diagnostics._0_cannot_be_used_as_a_value_because_it_was_imported_using_import_type;
-                        var unescapedName = ts.unescapeLeadingUnderscores(name);
-                        addTypeOnlyDeclarationRelatedInfo(error(errorLocation, message, unescapedName), typeOnlyDeclaration, unescapedName);
+                    if (result && errorLocation && meaning & 111551 && result.flags & 2097152 && !(result.flags & 111551) && !ts.isValidTypeOnlyAliasUseSite(errorLocation)) {
+                        var typeOnlyDeclaration = getTypeOnlyAliasDeclaration(result);
+                        if (typeOnlyDeclaration) {
+                            var message = typeOnlyDeclaration.kind === 275
+                                ? ts.Diagnostics._0_cannot_be_used_as_a_value_because_it_was_exported_using_export_type
+                                : ts.Diagnostics._0_cannot_be_used_as_a_value_because_it_was_imported_using_import_type;
+                            var unescapedName = ts.unescapeLeadingUnderscores(name);
+                            addTypeOnlyDeclarationRelatedInfo(error(errorLocation, message, unescapedName), typeOnlyDeclaration, unescapedName);
+                        }
                     }
-                }
+                });
             }
             return result;
         }
@@ -41920,9 +41932,7 @@ var ts;
             var result = new Type(checker, flags);
             typeCount++;
             result.id = typeCount;
-            if (produceDiagnostics) {
-                ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.recordType(result);
-            }
+            ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.recordType(result);
             return result;
         }
         function createOriginType(flags) {
@@ -46170,11 +46180,16 @@ var ts;
             }
             var type = resolveTypeOfAccessors(symbol, writing);
             if (!popTypeResolution()) {
-                type = anyType;
-                if (noImplicitAny) {
-                    var getter = ts.getDeclarationOfKind(symbol, 172);
-                    error(getter, ts.Diagnostics._0_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions, symbolToString(symbol));
+                var getter = ts.getDeclarationOfKind(symbol, 172);
+                if (getter) {
+                    if (ts.getEffectiveTypeAnnotationNode(getter)) {
+                        error(getter.name, ts.Diagnostics._0_is_referenced_directly_or_indirectly_in_its_own_type_annotation, symbolToString(symbol));
+                    }
+                    else if (noImplicitAny) {
+                        error(getter, ts.Diagnostics._0_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions, symbolToString(symbol));
+                    }
                 }
+                type = anyType;
             }
             return type;
         }
@@ -53584,6 +53599,7 @@ var ts;
                 return 0;
             }
             function reportErrorResults(originalSource, originalTarget, source, target, headMessage) {
+                var _a, _b;
                 var sourceHasBase = !!getSingleBaseForNonAugmentingSubtype(originalSource);
                 var targetHasBase = !!getSingleBaseForNonAugmentingSubtype(originalTarget);
                 source = (originalSource.aliasSymbol || sourceHasBase) ? originalSource : source;
@@ -53622,6 +53638,9 @@ var ts;
                     return;
                 }
                 reportRelationError(headMessage, source, target);
+                if (strictNullChecks && source.flags & 8650752 && ((_b = (_a = source.symbol) === null || _a === void 0 ? void 0 : _a.declarations) === null || _b === void 0 ? void 0 : _b[0]) && !getConstraintOfType(source) && isRelatedTo(emptyObjectType, extractTypesOfKind(target, ~67108864))) {
+                    associateRelatedInfo(ts.createDiagnosticForNode(source.symbol.declarations[0], ts.Diagnostics.This_type_parameter_probably_needs_an_extends_object_constraint));
+                }
             }
             function traceUnionsOrIntersectionsTooLarge(source, target) {
                 if (!ts.tracing) {
@@ -54251,17 +54270,17 @@ var ts;
                 if (sourceFlags & 8650752) {
                     if (!(sourceFlags & 8388608 && targetFlags & 8388608)) {
                         var constraint = getConstraintOfType(source);
-                        if (!constraint || (sourceFlags & 262144 && constraint.flags & 1)) {
+                        if (!strictNullChecks && (!constraint || (sourceFlags & 262144 && constraint.flags & 1))) {
                             if (result = isRelatedTo(emptyObjectType, extractTypesOfKind(target, ~67108864), 3)) {
                                 resetErrorInfo(saveErrorInfo);
                                 return result;
                             }
                         }
-                        else if (result = isRelatedTo(constraint, target, 1, false, undefined, intersectionState)) {
+                        else if (constraint && (result = isRelatedTo(constraint, target, 1, false, undefined, intersectionState))) {
                             resetErrorInfo(saveErrorInfo);
                             return result;
                         }
-                        else if (result = isRelatedTo(getTypeWithThisArgument(constraint, source), target, 1, reportErrors && !(targetFlags & sourceFlags & 262144), undefined, intersectionState)) {
+                        else if (constraint && (result = isRelatedTo(getTypeWithThisArgument(constraint, source), target, 1, reportErrors && !(targetFlags & sourceFlags & 262144), undefined, intersectionState))) {
                             resetErrorInfo(saveErrorInfo);
                             return result;
                         }
@@ -56036,11 +56055,13 @@ var ts;
             errorOrSuggestion(noImplicitAny, declaration, diagnostic, ts.declarationNameToString(ts.getNameOfDeclaration(declaration)), typeAsString);
         }
         function reportErrorsFromWidening(declaration, type, wideningKind) {
-            if (produceDiagnostics && noImplicitAny && ts.getObjectFlags(type) & 65536 && (!wideningKind || !getContextualSignatureForFunctionLikeDeclaration(declaration))) {
-                if (!reportWideningErrorsInType(type)) {
-                    reportImplicitAny(declaration, type, wideningKind);
+            addLazyDiagnostic(function () {
+                if (noImplicitAny && ts.getObjectFlags(type) & 65536 && (!wideningKind || !getContextualSignatureForFunctionLikeDeclaration(declaration))) {
+                    if (!reportWideningErrorsInType(type)) {
+                        reportImplicitAny(declaration, type, wideningKind);
+                    }
                 }
-            }
+            });
         }
         function applyToParameterTypes(source, target, callback) {
             var sourceCount = getParameterCount(source);
@@ -60204,21 +60225,11 @@ var ts;
             }
             return false;
         }
-        function uniqueStrings(strings) {
-            var unique = new ts.Set(strings);
-            var result = [];
-            unique.forEach(function (str) { return result.push(str); });
-            return result;
-        }
         function discriminateContextualTypeByObjectMembers(node, contextualType) {
-            return getMatchingUnionConstituentForObjectLiteral(contextualType, node) || discriminateTypeByDiscriminableItems(contextualType, ts.concatenate(ts.map(ts.filter(node.properties, function (p) { return !!p.symbol && p.kind === 296 && isPossiblyDiscriminantValue(p.initializer) && isDiscriminantProperty(contextualType, p.symbol.escapedName); }), function (prop) { return [function () { return getContextFreeTypeOfExpression(prop.initializer); }, prop.symbol.escapedName]; }), ts.map(uniqueStrings(ts.flatMap(contextualType.types, function (memberType) {
-                return ts.map(ts.filter(getPropertiesOfType(memberType), function (s) { var _a; return !!(s.flags & 16777216) && !!((_a = node === null || node === void 0 ? void 0 : node.symbol) === null || _a === void 0 ? void 0 : _a.members) && !node.symbol.members.has(s.escapedName) && isDiscriminantProperty(contextualType, s.escapedName); }), function (s) { return s.escapedName; });
-            })), function (name) { return [function () { return undefinedType; }, name]; })), isTypeAssignableTo, contextualType);
+            return getMatchingUnionConstituentForObjectLiteral(contextualType, node) || discriminateTypeByDiscriminableItems(contextualType, ts.concatenate(ts.map(ts.filter(node.properties, function (p) { return !!p.symbol && p.kind === 296 && isPossiblyDiscriminantValue(p.initializer) && isDiscriminantProperty(contextualType, p.symbol.escapedName); }), function (prop) { return [function () { return getContextFreeTypeOfExpression(prop.initializer); }, prop.symbol.escapedName]; }), ts.map(ts.filter(getPropertiesOfType(contextualType), function (s) { var _a; return !!(s.flags & 16777216) && !!((_a = node === null || node === void 0 ? void 0 : node.symbol) === null || _a === void 0 ? void 0 : _a.members) && !node.symbol.members.has(s.escapedName) && isDiscriminantProperty(contextualType, s.escapedName); }), function (s) { return [function () { return undefinedType; }, s.escapedName]; })), isTypeAssignableTo, contextualType);
         }
         function discriminateContextualTypeByJSXAttributes(node, contextualType) {
-            return discriminateTypeByDiscriminableItems(contextualType, ts.concatenate(ts.map(ts.filter(node.properties, function (p) { return !!p.symbol && p.kind === 285 && isDiscriminantProperty(contextualType, p.symbol.escapedName) && (!p.initializer || isPossiblyDiscriminantValue(p.initializer)); }), function (prop) { return [!prop.initializer ? (function () { return trueType; }) : (function () { return getContextFreeTypeOfExpression(prop.initializer); }), prop.symbol.escapedName]; }), ts.map(uniqueStrings(ts.flatMap(contextualType.types, function (memberType) {
-                return ts.map(ts.filter(getPropertiesOfType(memberType), function (s) { var _a; return !!(s.flags & 16777216) && !!((_a = node === null || node === void 0 ? void 0 : node.symbol) === null || _a === void 0 ? void 0 : _a.members) && !node.symbol.members.has(s.escapedName) && isDiscriminantProperty(contextualType, s.escapedName); }), function (s) { return s.escapedName; });
-            })), function (name) { return [function () { return undefinedType; }, name]; })), isTypeAssignableTo, contextualType);
+            return discriminateTypeByDiscriminableItems(contextualType, ts.concatenate(ts.map(ts.filter(node.properties, function (p) { return !!p.symbol && p.kind === 285 && isDiscriminantProperty(contextualType, p.symbol.escapedName) && (!p.initializer || isPossiblyDiscriminantValue(p.initializer)); }), function (prop) { return [!prop.initializer ? (function () { return trueType; }) : (function () { return getContextFreeTypeOfExpression(prop.initializer); }), prop.symbol.escapedName]; }), ts.map(ts.filter(getPropertiesOfType(contextualType), function (s) { var _a; return !!(s.flags & 16777216) && !!((_a = node === null || node === void 0 ? void 0 : node.symbol) === null || _a === void 0 ? void 0 : _a.members) && !node.symbol.members.has(s.escapedName) && isDiscriminantProperty(contextualType, s.escapedName); }), function (s) { return [function () { return undefinedType; }, s.escapedName]; })), isTypeAssignableTo, contextualType);
         }
         function getApparentTypeOfContextualType(node, contextFlags) {
             var contextualType = ts.isObjectLiteralMethod(node) ?
@@ -61812,6 +61823,7 @@ var ts;
                 && !isOptionalPropertyDeclaration(valueDeclaration)
                 && !(ts.isAccessExpression(node) && ts.isAccessExpression(node.expression))
                 && !isBlockScopedNameDeclaredBeforeUse(valueDeclaration, right)
+                && !(ts.isMethodDeclaration(valueDeclaration) && ts.getCombinedModifierFlags(valueDeclaration) & 32)
                 && (compilerOptions.useDefineForClassFields || !isPropertyDeclaredInAncestorClass(prop))) {
                 diagnosticMessage = error(right, ts.Diagnostics.Property_0_is_used_before_its_initialization, declarationName);
             }
@@ -62875,7 +62887,7 @@ var ts;
             var isTaggedTemplate = node.kind === 210;
             var isDecorator = node.kind === 165;
             var isJsxOpeningOrSelfClosingElement = ts.isJsxOpeningLikeElement(node);
-            var reportErrors = !candidatesOutArray && produceDiagnostics;
+            var reportErrors = !candidatesOutArray;
             var typeArguments;
             if (!isDecorator) {
                 typeArguments = node.typeArguments;
@@ -63955,11 +63967,13 @@ var ts;
             checkSourceElement(type);
             exprType = getRegularTypeOfObjectLiteral(getBaseTypeOfLiteralType(exprType));
             var targetType = getTypeFromTypeNode(type);
-            if (produceDiagnostics && !isErrorType(targetType)) {
-                var widenedType = getWidenedType(exprType);
-                if (!isTypeComparableTo(targetType, widenedType)) {
-                    checkTypeComparableTo(exprType, targetType, errNode, ts.Diagnostics.Conversion_of_type_0_to_type_1_may_be_a_mistake_because_neither_type_sufficiently_overlaps_with_the_other_If_this_was_intentional_convert_the_expression_to_unknown_first);
-                }
+            if (!isErrorType(targetType)) {
+                addLazyDiagnostic(function () {
+                    var widenedType = getWidenedType(exprType);
+                    if (!isTypeComparableTo(targetType, widenedType)) {
+                        checkTypeComparableTo(exprType, targetType, errNode, ts.Diagnostics.Conversion_of_type_0_to_type_1_may_be_a_mistake_because_neither_type_sufficiently_overlaps_with_the_other_If_this_was_intentional_convert_the_expression_to_unknown_first);
+                    }
+                });
             }
             return targetType;
         }
@@ -64643,39 +64657,40 @@ var ts;
             }
         }
         function checkAllCodePathsInNonVoidFunctionReturnOrThrow(func, returnType) {
-            if (!produceDiagnostics) {
-                return;
-            }
-            var functionFlags = ts.getFunctionFlags(func);
-            var type = returnType && unwrapReturnType(returnType, functionFlags);
-            if (type && maybeTypeOfKind(type, 1 | 16384)) {
-                return;
-            }
-            if (func.kind === 168 || ts.nodeIsMissing(func.body) || func.body.kind !== 235 || !functionHasImplicitReturn(func)) {
-                return;
-            }
-            var hasExplicitReturn = func.flags & 512;
-            var errorNode = ts.getEffectiveReturnTypeNode(func) || func;
-            if (type && type.flags & 131072) {
-                error(errorNode, ts.Diagnostics.A_function_returning_never_cannot_have_a_reachable_end_point);
-            }
-            else if (type && !hasExplicitReturn) {
-                error(errorNode, ts.Diagnostics.A_function_whose_declared_type_is_neither_void_nor_any_must_return_a_value);
-            }
-            else if (type && strictNullChecks && !isTypeAssignableTo(undefinedType, type)) {
-                error(errorNode, ts.Diagnostics.Function_lacks_ending_return_statement_and_return_type_does_not_include_undefined);
-            }
-            else if (compilerOptions.noImplicitReturns) {
-                if (!type) {
-                    if (!hasExplicitReturn) {
-                        return;
-                    }
-                    var inferredReturnType = getReturnTypeOfSignature(getSignatureFromDeclaration(func));
-                    if (isUnwrappedReturnTypeVoidOrAny(func, inferredReturnType)) {
-                        return;
+            addLazyDiagnostic(checkAllCodePathsInNonVoidFunctionReturnOrThrowDiagnostics);
+            return;
+            function checkAllCodePathsInNonVoidFunctionReturnOrThrowDiagnostics() {
+                var functionFlags = ts.getFunctionFlags(func);
+                var type = returnType && unwrapReturnType(returnType, functionFlags);
+                if (type && maybeTypeOfKind(type, 1 | 16384)) {
+                    return;
+                }
+                if (func.kind === 168 || ts.nodeIsMissing(func.body) || func.body.kind !== 235 || !functionHasImplicitReturn(func)) {
+                    return;
+                }
+                var hasExplicitReturn = func.flags & 512;
+                var errorNode = ts.getEffectiveReturnTypeNode(func) || func;
+                if (type && type.flags & 131072) {
+                    error(errorNode, ts.Diagnostics.A_function_returning_never_cannot_have_a_reachable_end_point);
+                }
+                else if (type && !hasExplicitReturn) {
+                    error(errorNode, ts.Diagnostics.A_function_whose_declared_type_is_neither_void_nor_any_must_return_a_value);
+                }
+                else if (type && strictNullChecks && !isTypeAssignableTo(undefinedType, type)) {
+                    error(errorNode, ts.Diagnostics.Function_lacks_ending_return_statement_and_return_type_does_not_include_undefined);
+                }
+                else if (compilerOptions.noImplicitReturns) {
+                    if (!type) {
+                        if (!hasExplicitReturn) {
+                            return;
+                        }
+                        var inferredReturnType = getReturnTypeOfSignature(getSignatureFromDeclaration(func));
+                        if (isUnwrappedReturnTypeVoidOrAny(func, inferredReturnType)) {
+                            return;
+                        }
                     }
+                    error(errorNode, ts.Diagnostics.Not_all_code_paths_return_a_value);
                 }
-                error(errorNode, ts.Diagnostics.Not_all_code_paths_return_a_value);
             }
         }
         function checkFunctionExpressionOrObjectLiteralMethod(node, checkMode) {
@@ -64901,47 +64916,48 @@ var ts;
             checkExpression(node.expression);
             return undefinedWideningType;
         }
-        function checkAwaitExpression(node) {
-            if (produceDiagnostics) {
-                var container = ts.getContainingFunctionOrClassStaticBlock(node);
-                if (container && ts.isClassStaticBlockDeclaration(container)) {
-                    error(node, ts.Diagnostics.Await_expression_cannot_be_used_inside_a_class_static_block);
-                }
-                else if (!(node.flags & 32768)) {
-                    if (ts.isInTopLevelContext(node)) {
-                        var sourceFile = ts.getSourceFileOfNode(node);
-                        if (!hasParseDiagnostics(sourceFile)) {
-                            var span = void 0;
-                            if (!ts.isEffectiveExternalModule(sourceFile, compilerOptions)) {
-                                if (!span)
-                                    span = ts.getSpanOfTokenAtPosition(sourceFile, node.pos);
-                                var diagnostic = ts.createFileDiagnostic(sourceFile, span.start, span.length, ts.Diagnostics.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);
-                                diagnostics.add(diagnostic);
-                            }
-                            if ((moduleKind !== ts.ModuleKind.ES2022 && moduleKind !== ts.ModuleKind.ESNext && moduleKind !== ts.ModuleKind.System && !(moduleKind === ts.ModuleKind.NodeNext && ts.getSourceFileOfNode(node).impliedNodeFormat === ts.ModuleKind.ESNext)) || languageVersion < 4) {
+        function checkAwaitExpressionGrammar(node) {
+            var container = ts.getContainingFunctionOrClassStaticBlock(node);
+            if (container && ts.isClassStaticBlockDeclaration(container)) {
+                error(node, ts.Diagnostics.Await_expression_cannot_be_used_inside_a_class_static_block);
+            }
+            else if (!(node.flags & 32768)) {
+                if (ts.isInTopLevelContext(node)) {
+                    var sourceFile = ts.getSourceFileOfNode(node);
+                    if (!hasParseDiagnostics(sourceFile)) {
+                        var span = void 0;
+                        if (!ts.isEffectiveExternalModule(sourceFile, compilerOptions)) {
+                            if (!span)
                                 span = ts.getSpanOfTokenAtPosition(sourceFile, node.pos);
-                                var diagnostic = ts.createFileDiagnostic(sourceFile, span.start, span.length, ts.Diagnostics.Top_level_await_expressions_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_or_nodenext_and_the_target_option_is_set_to_es2017_or_higher);
-                                diagnostics.add(diagnostic);
-                            }
+                            var diagnostic = ts.createFileDiagnostic(sourceFile, span.start, span.length, ts.Diagnostics.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);
+                            diagnostics.add(diagnostic);
                         }
-                    }
-                    else {
-                        var sourceFile = ts.getSourceFileOfNode(node);
-                        if (!hasParseDiagnostics(sourceFile)) {
-                            var span = ts.getSpanOfTokenAtPosition(sourceFile, node.pos);
-                            var diagnostic = ts.createFileDiagnostic(sourceFile, span.start, span.length, ts.Diagnostics.await_expressions_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules);
-                            if (container && container.kind !== 171 && (ts.getFunctionFlags(container) & 2) === 0) {
-                                var relatedInfo = ts.createDiagnosticForNode(container, ts.Diagnostics.Did_you_mean_to_mark_this_function_as_async);
-                                ts.addRelatedInfo(diagnostic, relatedInfo);
-                            }
+                        if ((moduleKind !== ts.ModuleKind.ES2022 && moduleKind !== ts.ModuleKind.ESNext && moduleKind !== ts.ModuleKind.System && !(moduleKind === ts.ModuleKind.NodeNext && ts.getSourceFileOfNode(node).impliedNodeFormat === ts.ModuleKind.ESNext)) || languageVersion < 4) {
+                            span = ts.getSpanOfTokenAtPosition(sourceFile, node.pos);
+                            var diagnostic = ts.createFileDiagnostic(sourceFile, span.start, span.length, ts.Diagnostics.Top_level_await_expressions_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_or_nodenext_and_the_target_option_is_set_to_es2017_or_higher);
                             diagnostics.add(diagnostic);
                         }
                     }
                 }
-                if (isInParameterInitializerBeforeContainingFunction(node)) {
-                    error(node, ts.Diagnostics.await_expressions_cannot_be_used_in_a_parameter_initializer);
+                else {
+                    var sourceFile = ts.getSourceFileOfNode(node);
+                    if (!hasParseDiagnostics(sourceFile)) {
+                        var span = ts.getSpanOfTokenAtPosition(sourceFile, node.pos);
+                        var diagnostic = ts.createFileDiagnostic(sourceFile, span.start, span.length, ts.Diagnostics.await_expressions_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules);
+                        if (container && container.kind !== 171 && (ts.getFunctionFlags(container) & 2) === 0) {
+                            var relatedInfo = ts.createDiagnosticForNode(container, ts.Diagnostics.Did_you_mean_to_mark_this_function_as_async);
+                            ts.addRelatedInfo(diagnostic, relatedInfo);
+                        }
+                        diagnostics.add(diagnostic);
+                    }
                 }
             }
+            if (isInParameterInitializerBeforeContainingFunction(node)) {
+                error(node, ts.Diagnostics.await_expressions_cannot_be_used_in_a_parameter_initializer);
+            }
+        }
+        function checkAwaitExpression(node) {
+            addLazyDiagnostic(function () { return checkAwaitExpressionGrammar(node); });
             var operandType = checkExpression(node.expression);
             var awaitedType = checkAwaitedType(operandType, true, node, ts.Diagnostics.Type_of_await_operand_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member);
             if (awaitedType === operandType && !isErrorType(awaitedType) && !(operandType.flags & 3)) {
@@ -65686,7 +65702,10 @@ var ts;
                 }
             }
             function checkAssignmentOperator(valueType) {
-                if (produceDiagnostics && ts.isAssignmentOperator(operator)) {
+                if (ts.isAssignmentOperator(operator)) {
+                    addLazyDiagnostic(checkAssignmentOperatorWorker);
+                }
+                function checkAssignmentOperatorWorker() {
                     if (checkReferenceExpression(left, ts.Diagnostics.The_left_hand_side_of_an_assignment_expression_must_be_a_variable_or_a_property_access, ts.Diagnostics.The_left_hand_side_of_an_assignment_expression_may_not_be_an_optional_property_access)
                         && (!ts.isIdentifier(left) || ts.unescapeLeadingUnderscores(left.escapedText) !== "exports")) {
                         var headMessage = void 0;
@@ -65775,14 +65794,7 @@ var ts;
             return [effectiveLeft, effectiveRight];
         }
         function checkYieldExpression(node) {
-            if (produceDiagnostics) {
-                if (!(node.flags & 8192)) {
-                    grammarErrorOnFirstToken(node, ts.Diagnostics.A_yield_expression_is_only_allowed_in_a_generator_body);
-                }
-                if (isInParameterInitializerBeforeContainingFunction(node)) {
-                    error(node, ts.Diagnostics.yield_expressions_cannot_be_used_in_a_parameter_initializer);
-                }
-            }
+            addLazyDiagnostic(checkYieldExpressionGrammar);
             var func = ts.getContainingFunction(node);
             if (!func)
                 return anyType;
@@ -65821,14 +65833,24 @@ var ts;
             var type = getContextualIterationType(2, func);
             if (!type) {
                 type = anyType;
-                if (produceDiagnostics && noImplicitAny && !ts.expressionResultIsUnused(node)) {
-                    var contextualType = getContextualType(node);
-                    if (!contextualType || isTypeAny(contextualType)) {
-                        error(node, ts.Diagnostics.yield_expression_implicitly_results_in_an_any_type_because_its_containing_generator_lacks_a_return_type_annotation);
+                addLazyDiagnostic(function () {
+                    if (noImplicitAny && !ts.expressionResultIsUnused(node)) {
+                        var contextualType = getContextualType(node);
+                        if (!contextualType || isTypeAny(contextualType)) {
+                            error(node, ts.Diagnostics.yield_expression_implicitly_results_in_an_any_type_because_its_containing_generator_lacks_a_return_type_annotation);
+                        }
                     }
-                }
+                });
             }
             return type;
+            function checkYieldExpressionGrammar() {
+                if (!(node.flags & 8192)) {
+                    grammarErrorOnFirstToken(node, ts.Diagnostics.A_yield_expression_is_only_allowed_in_a_generator_body);
+                }
+                if (isInParameterInitializerBeforeContainingFunction(node)) {
+                    error(node, ts.Diagnostics.yield_expressions_cannot_be_used_in_a_parameter_initializer);
+                }
+            }
         }
         function checkConditionalExpression(node, checkMode) {
             checkTruthinessExpression(node.condition);
@@ -66357,9 +66379,7 @@ var ts;
                     varianceTypeParameter = saveVarianceTypeParameter;
                 }
             }
-            if (produceDiagnostics) {
-                checkTypeNameIsReserved(node.name, ts.Diagnostics.Type_parameter_name_cannot_be_0);
-            }
+            addLazyDiagnostic(function () { return checkTypeNameIsReserved(node.name, ts.Diagnostics.Type_parameter_name_cannot_be_0); });
         }
         function checkParameter(node) {
             checkGrammarDecoratorsAndModifiers(node);
@@ -66498,7 +66518,8 @@ var ts;
             if (node.type) {
                 checkSourceElement(node.type);
             }
-            if (produceDiagnostics) {
+            addLazyDiagnostic(checkSignatureDeclarationDiagnostics);
+            function checkSignatureDeclarationDiagnostics() {
                 checkCollisionWithArgumentsInGeneratedCode(node);
                 var returnTypeNode = ts.getEffectiveReturnTypeNode(node);
                 if (noImplicitAny && !returnTypeNode) {
@@ -66750,9 +66771,8 @@ var ts;
             if (ts.nodeIsMissing(node.body)) {
                 return;
             }
-            if (!produceDiagnostics) {
-                return;
-            }
+            addLazyDiagnostic(checkConstructorDeclarationDiagnostics);
+            return;
             function isInstancePropertyWithInitializerOrPrivateIdentifierProperty(n) {
                 if (ts.isPrivateIdentifierClassElementDeclaration(n)) {
                     return true;
@@ -66761,42 +66781,44 @@ var ts;
                     !ts.isStatic(n) &&
                     !!n.initializer;
             }
-            var containingClassDecl = node.parent;
-            if (ts.getClassExtendsHeritageElement(containingClassDecl)) {
-                captureLexicalThis(node.parent, containingClassDecl);
-                var classExtendsNull = classDeclarationExtendsNull(containingClassDecl);
-                var superCall = findFirstSuperCall(node.body);
-                if (superCall) {
-                    if (classExtendsNull) {
-                        error(superCall, ts.Diagnostics.A_constructor_cannot_contain_a_super_call_when_its_class_extends_null);
-                    }
-                    var superCallShouldBeRootLevel = (ts.getEmitScriptTarget(compilerOptions) !== 99 || !useDefineForClassFields) &&
-                        (ts.some(node.parent.members, isInstancePropertyWithInitializerOrPrivateIdentifierProperty) ||
-                            ts.some(node.parameters, function (p) { return ts.hasSyntacticModifier(p, 16476); }));
-                    if (superCallShouldBeRootLevel) {
-                        if (!superCallIsRootLevelInConstructor(superCall, node.body)) {
-                            error(superCall, ts.Diagnostics.A_super_call_must_be_a_root_level_statement_within_a_constructor_of_a_derived_class_that_contains_initialized_properties_parameter_properties_or_private_identifiers);
-                        }
-                        else {
-                            var superCallStatement = void 0;
-                            for (var _i = 0, _a = node.body.statements; _i < _a.length; _i++) {
-                                var statement = _a[_i];
-                                if (ts.isExpressionStatement(statement) && ts.isSuperCall(ts.skipOuterExpressions(statement.expression))) {
-                                    superCallStatement = statement;
-                                    break;
+            function checkConstructorDeclarationDiagnostics() {
+                var containingClassDecl = node.parent;
+                if (ts.getClassExtendsHeritageElement(containingClassDecl)) {
+                    captureLexicalThis(node.parent, containingClassDecl);
+                    var classExtendsNull = classDeclarationExtendsNull(containingClassDecl);
+                    var superCall = findFirstSuperCall(node.body);
+                    if (superCall) {
+                        if (classExtendsNull) {
+                            error(superCall, ts.Diagnostics.A_constructor_cannot_contain_a_super_call_when_its_class_extends_null);
+                        }
+                        var superCallShouldBeRootLevel = (ts.getEmitScriptTarget(compilerOptions) !== 99 || !useDefineForClassFields) &&
+                            (ts.some(node.parent.members, isInstancePropertyWithInitializerOrPrivateIdentifierProperty) ||
+                                ts.some(node.parameters, function (p) { return ts.hasSyntacticModifier(p, 16476); }));
+                        if (superCallShouldBeRootLevel) {
+                            if (!superCallIsRootLevelInConstructor(superCall, node.body)) {
+                                error(superCall, ts.Diagnostics.A_super_call_must_be_a_root_level_statement_within_a_constructor_of_a_derived_class_that_contains_initialized_properties_parameter_properties_or_private_identifiers);
+                            }
+                            else {
+                                var superCallStatement = void 0;
+                                for (var _i = 0, _a = node.body.statements; _i < _a.length; _i++) {
+                                    var statement = _a[_i];
+                                    if (ts.isExpressionStatement(statement) && ts.isSuperCall(ts.skipOuterExpressions(statement.expression))) {
+                                        superCallStatement = statement;
+                                        break;
+                                    }
+                                    if (!ts.isPrologueDirective(statement) && nodeImmediatelyReferencesSuperOrThis(statement)) {
+                                        break;
+                                    }
                                 }
-                                if (!ts.isPrologueDirective(statement) && nodeImmediatelyReferencesSuperOrThis(statement)) {
-                                    break;
+                                if (superCallStatement === undefined) {
+                                    error(node, ts.Diagnostics.A_super_call_must_be_the_first_statement_in_the_constructor_to_refer_to_super_or_this_when_a_derived_class_contains_initialized_properties_parameter_properties_or_private_identifiers);
                                 }
                             }
-                            if (superCallStatement === undefined) {
-                                error(node, ts.Diagnostics.A_super_call_must_be_the_first_statement_in_the_constructor_to_refer_to_super_or_this_when_a_derived_class_contains_initialized_properties_parameter_properties_or_private_identifiers);
-                            }
                         }
                     }
-                }
-                else if (!classExtendsNull) {
-                    error(node, ts.Diagnostics.Constructors_for_derived_classes_must_contain_a_super_call);
+                    else if (!classExtendsNull) {
+                        error(node, ts.Diagnostics.Constructors_for_derived_classes_must_contain_a_super_call);
+                    }
                 }
             }
         }
@@ -66814,7 +66836,10 @@ var ts;
             return !!ts.forEachChild(node, nodeImmediatelyReferencesSuperOrThis);
         }
         function checkAccessorDeclaration(node) {
-            if (produceDiagnostics) {
+            addLazyDiagnostic(checkAccessorDeclarationDiagnostics);
+            checkSourceElement(node.body);
+            setNodeLinksForPrivateIdentifierScope(node);
+            function checkAccessorDeclarationDiagnostics() {
                 if (!checkGrammarFunctionLikeDeclaration(node) && !checkGrammarAccessor(node))
                     checkGrammarComputedPropertyName(node.name);
                 checkDecorators(node);
@@ -66858,8 +66883,6 @@ var ts;
                     checkAllCodePathsInNonVoidFunctionReturnOrThrow(node, returnType);
                 }
             }
-            checkSourceElement(node.body);
-            setNodeLinksForPrivateIdentifierScope(node);
         }
         function checkMissingDeclaration(node) {
             checkDecorators(node);
@@ -66902,11 +66925,13 @@ var ts;
             ts.forEach(node.typeArguments, checkSourceElement);
             var type = getTypeFromTypeReference(node);
             if (!isErrorType(type)) {
-                if (node.typeArguments && produceDiagnostics) {
-                    var typeParameters = getTypeParametersForTypeReference(node);
-                    if (typeParameters) {
-                        checkTypeArgumentConstraints(node, typeParameters);
-                    }
+                if (node.typeArguments) {
+                    addLazyDiagnostic(function () {
+                        var typeParameters = getTypeParametersForTypeReference(node);
+                        if (typeParameters) {
+                            checkTypeArgumentConstraints(node, typeParameters);
+                        }
+                    });
                 }
                 var symbol = getNodeLinks(node).resolvedSymbol;
                 if (symbol) {
@@ -66934,7 +66959,8 @@ var ts;
         }
         function checkTypeLiteral(node) {
             ts.forEach(node.members, checkSourceElement);
-            if (produceDiagnostics) {
+            addLazyDiagnostic(checkTypeLiteralDiagnostics);
+            function checkTypeLiteralDiagnostics() {
                 var type = getTypeFromTypeLiteralOrFunctionOrConstructorTypeNode(node);
                 checkIndexConstraints(type, type.symbol);
                 checkTypeForDuplicateIndexSignatures(node);
@@ -67119,9 +67145,9 @@ var ts;
             return flags & flagsToCheck;
         }
         function checkFunctionOrConstructorSymbol(symbol) {
-            if (!produceDiagnostics) {
-                return;
-            }
+            addLazyDiagnostic(function () { return checkFunctionOrConstructorSymbolWorker(symbol); });
+        }
+        function checkFunctionOrConstructorSymbolWorker(symbol) {
             function getCanonicalOverload(overloads, implementation) {
                 var implementationSharesContainerWithFirstOverload = implementation !== undefined && implementation.parent === overloads[0].parent;
                 return implementationSharesContainerWithFirstOverload ? implementation : overloads[0];
@@ -67314,9 +67340,9 @@ var ts;
             }
         }
         function checkExportsOnMergedDeclarations(node) {
-            if (!produceDiagnostics) {
-                return;
-            }
+            addLazyDiagnostic(function () { return checkExportsOnMergedDeclarationsWorker(node); });
+        }
+        function checkExportsOnMergedDeclarationsWorker(node) {
             var symbol = node.localSymbol;
             if (!symbol) {
                 symbol = getSymbolOfNode(node);
@@ -67764,7 +67790,8 @@ var ts;
             ts.forEach(node.decorators, checkDecorator);
         }
         function checkFunctionDeclaration(node) {
-            if (produceDiagnostics) {
+            addLazyDiagnostic(checkFunctionDeclarationDiagnostics);
+            function checkFunctionDeclarationDiagnostics() {
                 checkFunctionOrMethodDeclaration(node);
                 checkGrammarForGenerator(node);
                 checkCollisionsForDeclarationName(node, node.name);
@@ -67797,10 +67824,13 @@ var ts;
             checkSourceElement(node.typeExpression);
         }
         function checkJSDocFunctionType(node) {
-            if (produceDiagnostics && !node.type && !ts.isJSDocConstructSignature(node)) {
-                reportImplicitAny(node, anyType);
-            }
+            addLazyDiagnostic(checkJSDocFunctionTypeImplicitAny);
             checkSignatureDeclaration(node);
+            function checkJSDocFunctionTypeImplicitAny() {
+                if (!node.type && !ts.isJSDocConstructSignature(node)) {
+                    reportImplicitAny(node, anyType);
+                }
+            }
         }
         function checkJSDocImplementsTag(node) {
             var classLike = ts.getEffectiveJSDocHost(node);
@@ -67866,23 +67896,27 @@ var ts;
             var body = node.kind === 168 ? undefined : node.body;
             checkSourceElement(body);
             checkAllCodePathsInNonVoidFunctionReturnOrThrow(node, getReturnTypeFromAnnotation(node));
-            if (produceDiagnostics && !ts.getEffectiveReturnTypeNode(node)) {
-                if (ts.nodeIsMissing(body) && !isPrivateWithinAmbient(node)) {
-                    reportImplicitAny(node, anyType);
-                }
-                if (functionFlags & 1 && ts.nodeIsPresent(body)) {
-                    getReturnTypeOfSignature(getSignatureFromDeclaration(node));
-                }
-            }
+            addLazyDiagnostic(checkFunctionOrMethodDeclarationDiagnostics);
             if (ts.isInJSFile(node)) {
                 var typeTag = ts.getJSDocTypeTag(node);
                 if (typeTag && typeTag.typeExpression && !getContextualCallSignature(getTypeFromTypeNode(typeTag.typeExpression), node)) {
                     error(typeTag.typeExpression.type, ts.Diagnostics.The_type_of_a_function_declaration_must_match_the_function_s_signature);
                 }
             }
+            function checkFunctionOrMethodDeclarationDiagnostics() {
+                if (!ts.getEffectiveReturnTypeNode(node)) {
+                    if (ts.nodeIsMissing(body) && !isPrivateWithinAmbient(node)) {
+                        reportImplicitAny(node, anyType);
+                    }
+                    if (functionFlags & 1 && ts.nodeIsPresent(body)) {
+                        getReturnTypeOfSignature(getSignatureFromDeclaration(node));
+                    }
+                }
+            }
         }
         function registerForUnusedIdentifiersCheck(node) {
-            if (produceDiagnostics) {
+            addLazyDiagnostic(registerForUnusedIdentifiersCheckDiagnostics);
+            function registerForUnusedIdentifiersCheckDiagnostics() {
                 var sourceFile = ts.getSourceFileOfNode(node);
                 var potentiallyUnusedIdentifiers = allPotentiallyUnusedIdentifiers.get(sourceFile.path);
                 if (!potentiallyUnusedIdentifiers) {
@@ -69311,22 +69345,27 @@ var ts;
                         hasDuplicateDefaultClause = true;
                     }
                 }
-                if (produceDiagnostics && clause.kind === 289) {
-                    var caseType = checkExpression(clause.expression);
-                    var caseIsLiteral = isLiteralType(caseType);
-                    var comparedExpressionType = expressionType;
-                    if (!caseIsLiteral || !expressionIsLiteral) {
-                        caseType = caseIsLiteral ? getBaseTypeOfLiteralType(caseType) : caseType;
-                        comparedExpressionType = getBaseTypeOfLiteralType(expressionType);
-                    }
-                    if (!isTypeEqualityComparableTo(comparedExpressionType, caseType)) {
-                        checkTypeComparableTo(caseType, comparedExpressionType, clause.expression, undefined);
-                    }
+                if (clause.kind === 289) {
+                    addLazyDiagnostic(createLazyCaseClauseDiagnostics(clause));
                 }
                 ts.forEach(clause.statements, checkSourceElement);
                 if (compilerOptions.noFallthroughCasesInSwitch && clause.fallthroughFlowNode && isReachableFlowNode(clause.fallthroughFlowNode)) {
                     error(clause, ts.Diagnostics.Fallthrough_case_in_switch);
                 }
+                function createLazyCaseClauseDiagnostics(clause) {
+                    return function () {
+                        var caseType = checkExpression(clause.expression);
+                        var caseIsLiteral = isLiteralType(caseType);
+                        var comparedExpressionType = expressionType;
+                        if (!caseIsLiteral || !expressionIsLiteral) {
+                            caseType = caseIsLiteral ? getBaseTypeOfLiteralType(caseType) : caseType;
+                            comparedExpressionType = getBaseTypeOfLiteralType(expressionType);
+                        }
+                        if (!isTypeEqualityComparableTo(comparedExpressionType, caseType)) {
+                            checkTypeComparableTo(caseType, comparedExpressionType, clause.expression, undefined);
+                        }
+                    };
+                }
             });
             if (node.caseBlock.locals) {
                 registerForUnusedIdentifiersCheck(node.caseBlock);
@@ -69526,26 +69565,29 @@ var ts;
             }
         }
         function checkTypeParameters(typeParameterDeclarations) {
+            var seenDefault = false;
             if (typeParameterDeclarations) {
-                var seenDefault = false;
                 for (var i = 0; i < typeParameterDeclarations.length; i++) {
                     var node = typeParameterDeclarations[i];
                     checkTypeParameter(node);
-                    if (produceDiagnostics) {
-                        if (node.default) {
-                            seenDefault = true;
-                            checkTypeParametersNotReferenced(node.default, typeParameterDeclarations, i);
-                        }
-                        else if (seenDefault) {
-                            error(node, ts.Diagnostics.Required_type_parameters_may_not_follow_optional_type_parameters);
-                        }
-                        for (var j = 0; j < i; j++) {
-                            if (typeParameterDeclarations[j].symbol === node.symbol) {
-                                error(node.name, ts.Diagnostics.Duplicate_identifier_0, ts.declarationNameToString(node.name));
-                            }
+                    addLazyDiagnostic(createCheckTypeParameterDiagnostic(node, i));
+                }
+            }
+            function createCheckTypeParameterDiagnostic(node, i) {
+                return function () {
+                    if (node.default) {
+                        seenDefault = true;
+                        checkTypeParametersNotReferenced(node.default, typeParameterDeclarations, i);
+                    }
+                    else if (seenDefault) {
+                        error(node, ts.Diagnostics.Required_type_parameters_may_not_follow_optional_type_parameters);
+                    }
+                    for (var j = 0; j < i; j++) {
+                        if (typeParameterDeclarations[j].symbol === node.symbol) {
+                            error(node.name, ts.Diagnostics.Duplicate_identifier_0, ts.declarationNameToString(node.name));
                         }
                     }
-                }
+                };
             }
         }
         function checkTypeParametersNotReferenced(root, typeParameters, index) {
@@ -69663,82 +69705,87 @@ var ts;
                 if (extendsNode && extendsNode !== baseTypeNode) {
                     checkExpression(extendsNode.expression);
                 }
-                var baseTypes = getBaseTypes(type);
-                if (baseTypes.length && produceDiagnostics) {
-                    var baseType_1 = baseTypes[0];
-                    var baseConstructorType = getBaseConstructorTypeOfClass(type);
-                    var staticBaseType = getApparentType(baseConstructorType);
-                    checkBaseTypeAccessibility(staticBaseType, baseTypeNode);
-                    checkSourceElement(baseTypeNode.expression);
-                    if (ts.some(baseTypeNode.typeArguments)) {
-                        ts.forEach(baseTypeNode.typeArguments, checkSourceElement);
-                        for (var _i = 0, _a = getConstructorsForTypeArguments(staticBaseType, baseTypeNode.typeArguments, baseTypeNode); _i < _a.length; _i++) {
-                            var constructor = _a[_i];
-                            if (!checkTypeArgumentConstraints(baseTypeNode, constructor.typeParameters)) {
-                                break;
+                var baseTypes_2 = getBaseTypes(type);
+                if (baseTypes_2.length) {
+                    addLazyDiagnostic(function () {
+                        var baseType = baseTypes_2[0];
+                        var baseConstructorType = getBaseConstructorTypeOfClass(type);
+                        var staticBaseType = getApparentType(baseConstructorType);
+                        checkBaseTypeAccessibility(staticBaseType, baseTypeNode);
+                        checkSourceElement(baseTypeNode.expression);
+                        if (ts.some(baseTypeNode.typeArguments)) {
+                            ts.forEach(baseTypeNode.typeArguments, checkSourceElement);
+                            for (var _i = 0, _a = getConstructorsForTypeArguments(staticBaseType, baseTypeNode.typeArguments, baseTypeNode); _i < _a.length; _i++) {
+                                var constructor = _a[_i];
+                                if (!checkTypeArgumentConstraints(baseTypeNode, constructor.typeParameters)) {
+                                    break;
+                                }
                             }
                         }
-                    }
-                    var baseWithThis = getTypeWithThisArgument(baseType_1, type.thisType);
-                    if (!checkTypeAssignableTo(typeWithThis, baseWithThis, undefined)) {
-                        issueMemberSpecificError(node, typeWithThis, baseWithThis, ts.Diagnostics.Class_0_incorrectly_extends_base_class_1);
-                    }
-                    else {
-                        checkTypeAssignableTo(staticType, getTypeWithoutSignatures(staticBaseType), node.name || node, ts.Diagnostics.Class_static_side_0_incorrectly_extends_base_class_static_side_1);
-                    }
-                    if (baseConstructorType.flags & 8650752) {
-                        if (!isMixinConstructorType(staticType)) {
-                            error(node.name || node, ts.Diagnostics.A_mixin_class_must_have_a_constructor_with_a_single_rest_parameter_of_type_any);
+                        var baseWithThis = getTypeWithThisArgument(baseType, type.thisType);
+                        if (!checkTypeAssignableTo(typeWithThis, baseWithThis, undefined)) {
+                            issueMemberSpecificError(node, typeWithThis, baseWithThis, ts.Diagnostics.Class_0_incorrectly_extends_base_class_1);
                         }
                         else {
-                            var constructSignatures = getSignaturesOfType(baseConstructorType, 1);
-                            if (constructSignatures.some(function (signature) { return signature.flags & 4; }) && !ts.hasSyntacticModifier(node, 128)) {
-                                error(node.name || node, ts.Diagnostics.A_mixin_class_that_extends_from_a_type_variable_containing_an_abstract_construct_signature_must_also_be_declared_abstract);
+                            checkTypeAssignableTo(staticType, getTypeWithoutSignatures(staticBaseType), node.name || node, ts.Diagnostics.Class_static_side_0_incorrectly_extends_base_class_static_side_1);
+                        }
+                        if (baseConstructorType.flags & 8650752) {
+                            if (!isMixinConstructorType(staticType)) {
+                                error(node.name || node, ts.Diagnostics.A_mixin_class_must_have_a_constructor_with_a_single_rest_parameter_of_type_any);
+                            }
+                            else {
+                                var constructSignatures = getSignaturesOfType(baseConstructorType, 1);
+                                if (constructSignatures.some(function (signature) { return signature.flags & 4; }) && !ts.hasSyntacticModifier(node, 128)) {
+                                    error(node.name || node, ts.Diagnostics.A_mixin_class_that_extends_from_a_type_variable_containing_an_abstract_construct_signature_must_also_be_declared_abstract);
+                                }
                             }
                         }
-                    }
-                    if (!(staticBaseType.symbol && staticBaseType.symbol.flags & 32) && !(baseConstructorType.flags & 8650752)) {
-                        var constructors = getInstantiatedConstructorsForTypeArguments(staticBaseType, baseTypeNode.typeArguments, baseTypeNode);
-                        if (ts.forEach(constructors, function (sig) { return !isJSConstructor(sig.declaration) && !isTypeIdenticalTo(getReturnTypeOfSignature(sig), baseType_1); })) {
-                            error(baseTypeNode.expression, ts.Diagnostics.Base_constructors_must_all_have_the_same_return_type);
+                        if (!(staticBaseType.symbol && staticBaseType.symbol.flags & 32) && !(baseConstructorType.flags & 8650752)) {
+                            var constructors = getInstantiatedConstructorsForTypeArguments(staticBaseType, baseTypeNode.typeArguments, baseTypeNode);
+                            if (ts.forEach(constructors, function (sig) { return !isJSConstructor(sig.declaration) && !isTypeIdenticalTo(getReturnTypeOfSignature(sig), baseType); })) {
+                                error(baseTypeNode.expression, ts.Diagnostics.Base_constructors_must_all_have_the_same_return_type);
+                            }
                         }
-                    }
-                    checkKindsOfPropertyMemberOverrides(type, baseType_1);
+                        checkKindsOfPropertyMemberOverrides(type, baseType);
+                    });
                 }
             }
             checkMembersForOverrideModifier(node, type, typeWithThis, staticType);
             var implementedTypeNodes = ts.getEffectiveImplementsTypeNodes(node);
             if (implementedTypeNodes) {
-                for (var _b = 0, implementedTypeNodes_1 = implementedTypeNodes; _b < implementedTypeNodes_1.length; _b++) {
-                    var typeRefNode = implementedTypeNodes_1[_b];
+                for (var _i = 0, implementedTypeNodes_1 = implementedTypeNodes; _i < implementedTypeNodes_1.length; _i++) {
+                    var typeRefNode = implementedTypeNodes_1[_i];
                     if (!ts.isEntityNameExpression(typeRefNode.expression) || ts.isOptionalChain(typeRefNode.expression)) {
                         error(typeRefNode.expression, ts.Diagnostics.A_class_can_only_implement_an_identifier_Slashqualified_name_with_optional_type_arguments);
                     }
                     checkTypeReferenceNode(typeRefNode);
-                    if (produceDiagnostics) {
-                        var t = getReducedType(getTypeFromTypeNode(typeRefNode));
-                        if (!isErrorType(t)) {
-                            if (isValidBaseType(t)) {
-                                var genericDiag = t.symbol && t.symbol.flags & 32 ?
-                                    ts.Diagnostics.Class_0_incorrectly_implements_class_1_Did_you_mean_to_extend_1_and_inherit_its_members_as_a_subclass :
-                                    ts.Diagnostics.Class_0_incorrectly_implements_interface_1;
-                                var baseWithThis = getTypeWithThisArgument(t, type.thisType);
-                                if (!checkTypeAssignableTo(typeWithThis, baseWithThis, undefined)) {
-                                    issueMemberSpecificError(node, typeWithThis, baseWithThis, genericDiag);
-                                }
-                            }
-                            else {
-                                error(typeRefNode, ts.Diagnostics.A_class_can_only_implement_an_object_type_or_intersection_of_object_types_with_statically_known_members);
-                            }
-                        }
-                    }
+                    addLazyDiagnostic(createImplementsDiagnostics(typeRefNode));
                 }
             }
-            if (produceDiagnostics) {
+            addLazyDiagnostic(function () {
                 checkIndexConstraints(type, symbol);
                 checkIndexConstraints(staticType, symbol, true);
                 checkTypeForDuplicateIndexSignatures(node);
                 checkPropertyInitialization(node);
+            });
+            function createImplementsDiagnostics(typeRefNode) {
+                return function () {
+                    var t = getReducedType(getTypeFromTypeNode(typeRefNode));
+                    if (!isErrorType(t)) {
+                        if (isValidBaseType(t)) {
+                            var genericDiag = t.symbol && t.symbol.flags & 32 ?
+                                ts.Diagnostics.Class_0_incorrectly_implements_class_1_Did_you_mean_to_extend_1_and_inherit_its_members_as_a_subclass :
+                                ts.Diagnostics.Class_0_incorrectly_implements_interface_1;
+                            var baseWithThis = getTypeWithThisArgument(t, type.thisType);
+                            if (!checkTypeAssignableTo(typeWithThis, baseWithThis, undefined)) {
+                                issueMemberSpecificError(node, typeWithThis, baseWithThis, genericDiag);
+                            }
+                        }
+                        else {
+                            error(typeRefNode, ts.Diagnostics.A_class_can_only_implement_an_object_type_or_intersection_of_object_types_with_statically_known_members);
+                        }
+                    }
+                };
             }
         }
         function checkMembersForOverrideModifier(node, type, typeWithThis, staticType) {
@@ -70005,8 +70052,8 @@ var ts;
             ts.forEach(properties, function (p) {
                 seen.set(p.escapedName, p);
             });
-            for (var _i = 0, baseTypes_2 = baseTypes; _i < baseTypes_2.length; _i++) {
-                var base = baseTypes_2[_i];
+            for (var _i = 0, baseTypes_3 = baseTypes; _i < baseTypes_3.length; _i++) {
+                var base = baseTypes_3[_i];
                 var properties_5 = getPropertiesOfType(getTypeWithThisArgument(base, type.thisType));
                 for (var _a = 0, properties_4 = properties_5; _a < properties_4.length; _a++) {
                     var prop = properties_4[_a];
@@ -70028,8 +70075,8 @@ var ts;
                 seen.set(p.escapedName, { prop: p, containingType: type });
             });
             var ok = true;
-            for (var _i = 0, baseTypes_3 = baseTypes; _i < baseTypes_3.length; _i++) {
-                var base = baseTypes_3[_i];
+            for (var _i = 0, baseTypes_4 = baseTypes; _i < baseTypes_4.length; _i++) {
+                var base = baseTypes_4[_i];
                 var properties = getPropertiesOfType(getTypeWithThisArgument(base, type.thisType));
                 for (var _a = 0, properties_6 = properties; _a < properties_6.length; _a++) {
                     var prop = properties_6[_a];
@@ -70111,7 +70158,7 @@ var ts;
             if (!checkGrammarDecoratorsAndModifiers(node))
                 checkGrammarInterfaceDeclaration(node);
             checkTypeParameters(node.typeParameters);
-            if (produceDiagnostics) {
+            addLazyDiagnostic(function () {
                 checkTypeNameIsReserved(node.name, ts.Diagnostics.Interface_name_cannot_be_0);
                 checkExportsOnMergedDeclarations(node);
                 var symbol = getSymbolOfNode(node);
@@ -70129,7 +70176,7 @@ var ts;
                     }
                 }
                 checkObjectTypeForDuplicateDeclarations(node);
-            }
+            });
             ts.forEach(ts.getInterfaceBaseTypeNodes(node), function (heritageElement) {
                 if (!ts.isEntityNameExpression(heritageElement.expression) || ts.isOptionalChain(heritageElement.expression)) {
                     error(heritageElement.expression, ts.Diagnostics.An_interface_can_only_extend_an_identifier_Slashqualified_name_with_optional_type_arguments);
@@ -70137,10 +70184,10 @@ var ts;
                 checkTypeReferenceNode(heritageElement);
             });
             ts.forEach(node.members, checkSourceElement);
-            if (produceDiagnostics) {
+            addLazyDiagnostic(function () {
                 checkTypeForDuplicateIndexSignatures(node);
                 registerForUnusedIdentifiersCheck(node);
-            }
+            });
         }
         function checkTypeAliasDeclaration(node) {
             checkGrammarDecoratorsAndModifiers(node);
@@ -70321,9 +70368,9 @@ var ts;
                     ts.isStringLiteralLike(node.argumentExpression);
         }
         function checkEnumDeclaration(node) {
-            if (!produceDiagnostics) {
-                return;
-            }
+            addLazyDiagnostic(function () { return checkEnumDeclarationWorker(node); });
+        }
+        function checkEnumDeclarationWorker(node) {
             checkGrammarDecoratorsAndModifiers(node);
             checkCollisionsForDeclarationName(node, node.name);
             checkExportsOnMergedDeclarations(node);
@@ -70394,7 +70441,14 @@ var ts;
             }
         }
         function checkModuleDeclaration(node) {
-            if (produceDiagnostics) {
+            if (node.body) {
+                checkSourceElement(node.body);
+                if (!ts.isGlobalScopeAugmentation(node)) {
+                    registerForUnusedIdentifiersCheck(node);
+                }
+            }
+            addLazyDiagnostic(checkModuleDeclarationDiagnostics);
+            function checkModuleDeclarationDiagnostics() {
                 var isGlobalAugmentation = ts.isGlobalScopeAugmentation(node);
                 var inAmbientContext = node.flags & 8388608;
                 if (isGlobalAugmentation && !inAmbientContext) {
@@ -70465,12 +70519,6 @@ var ts;
                     }
                 }
             }
-            if (node.body) {
-                checkSourceElement(node.body);
-                if (!ts.isGlobalScopeAugmentation(node)) {
-                    registerForUnusedIdentifiersCheck(node);
-                }
-            }
         }
         function checkModuleAugmentationElement(node, isGlobalAugmentation) {
             var _a;
@@ -71329,13 +71377,15 @@ var ts;
                 if (ts.isExternalOrCommonJsModule(node)) {
                     registerForUnusedIdentifiersCheck(node);
                 }
-                if (!node.isDeclarationFile && (compilerOptions.noUnusedLocals || compilerOptions.noUnusedParameters)) {
-                    checkUnusedIdentifiers(getPotentiallyUnusedIdentifiers(node), function (containingNode, kind, diag) {
-                        if (!ts.containsParseError(containingNode) && unusedIsError(kind, !!(containingNode.flags & 8388608))) {
-                            diagnostics.add(diag);
-                        }
-                    });
-                }
+                addLazyDiagnostic(function () {
+                    if (!node.isDeclarationFile && (compilerOptions.noUnusedLocals || compilerOptions.noUnusedParameters)) {
+                        checkUnusedIdentifiers(getPotentiallyUnusedIdentifiers(node), function (containingNode, kind, diag) {
+                            if (!ts.containsParseError(containingNode) && unusedIsError(kind, !!(containingNode.flags & 8388608))) {
+                                diagnostics.add(diag);
+                            }
+                        });
+                    }
+                });
                 if (compilerOptions.importsNotUsedAsValues === 2 &&
                     !node.isDeclarationFile &&
                     ts.isExternalModule(node)) {
@@ -71372,12 +71422,26 @@ var ts;
                 cancellationToken = undefined;
             }
         }
+        function ensurePendingDiagnosticWorkComplete() {
+            for (var _i = 0, deferredDiagnosticsCallbacks_1 = deferredDiagnosticsCallbacks; _i < deferredDiagnosticsCallbacks_1.length; _i++) {
+                var cb = deferredDiagnosticsCallbacks_1[_i];
+                cb();
+            }
+            deferredDiagnosticsCallbacks = [];
+        }
+        function checkSourceFileWithEagerDiagnostics(sourceFile) {
+            ensurePendingDiagnosticWorkComplete();
+            var oldAddLazyDiagnostics = addLazyDiagnostic;
+            addLazyDiagnostic = function (cb) { return cb(); };
+            checkSourceFile(sourceFile);
+            addLazyDiagnostic = oldAddLazyDiagnostics;
+        }
         function getDiagnosticsWorker(sourceFile) {
-            throwIfNonDiagnosticsProducing();
             if (sourceFile) {
+                ensurePendingDiagnosticWorkComplete();
                 var previousGlobalDiagnostics = diagnostics.getGlobalDiagnostics();
                 var previousGlobalDiagnosticsSize = previousGlobalDiagnostics.length;
-                checkSourceFile(sourceFile);
+                checkSourceFileWithEagerDiagnostics(sourceFile);
                 var semanticDiagnostics = diagnostics.getDiagnostics(sourceFile.fileName);
                 var currentGlobalDiagnostics = diagnostics.getGlobalDiagnostics();
                 if (currentGlobalDiagnostics !== previousGlobalDiagnostics) {
@@ -71389,18 +71453,13 @@ var ts;
                 }
                 return semanticDiagnostics;
             }
-            ts.forEach(host.getSourceFiles(), checkSourceFile);
+            ts.forEach(host.getSourceFiles(), checkSourceFileWithEagerDiagnostics);
             return diagnostics.getDiagnostics();
         }
         function getGlobalDiagnostics() {
-            throwIfNonDiagnosticsProducing();
+            ensurePendingDiagnosticWorkComplete();
             return diagnostics.getGlobalDiagnostics();
         }
-        function throwIfNonDiagnosticsProducing() {
-            if (!produceDiagnostics) {
-                throw new Error("Trying to get diagnostics from a type checker that does not produce them.");
-            }
-        }
         function getSymbolsInScope(location, meaning) {
             if (location.flags & 16777216) {
                 return [];
@@ -95394,8 +95453,7 @@ var ts;
         var files;
         var symlinks;
         var commonSourceDirectory;
-        var diagnosticsProducingTypeChecker;
-        var noDiagnosticsTypeChecker;
+        var typeChecker;
         var classifiableNames;
         var ambientModuleNameToUnmodifiedFileName = new ts.Map();
         var fileReasons = ts.createMultiMap();
@@ -95599,21 +95657,19 @@ var ts;
             getProgramDiagnostics: getProgramDiagnostics,
             getTypeChecker: getTypeChecker,
             getClassifiableNames: getClassifiableNames,
-            getDiagnosticsProducingTypeChecker: getDiagnosticsProducingTypeChecker,
             getCommonSourceDirectory: getCommonSourceDirectory,
             emit: emit,
             getCurrentDirectory: function () { return currentDirectory; },
-            getNodeCount: function () { return getDiagnosticsProducingTypeChecker().getNodeCount(); },
-            getIdentifierCount: function () { return getDiagnosticsProducingTypeChecker().getIdentifierCount(); },
-            getSymbolCount: function () { return getDiagnosticsProducingTypeChecker().getSymbolCount(); },
-            getTypeCount: function () { return getDiagnosticsProducingTypeChecker().getTypeCount(); },
-            getInstantiationCount: function () { return getDiagnosticsProducingTypeChecker().getInstantiationCount(); },
-            getRelationCacheSizes: function () { return getDiagnosticsProducingTypeChecker().getRelationCacheSizes(); },
+            getNodeCount: function () { return getTypeChecker().getNodeCount(); },
+            getIdentifierCount: function () { return getTypeChecker().getIdentifierCount(); },
+            getSymbolCount: function () { return getTypeChecker().getSymbolCount(); },
+            getTypeCount: function () { return getTypeChecker().getTypeCount(); },
+            getInstantiationCount: function () { return getTypeChecker().getInstantiationCount(); },
+            getRelationCacheSizes: function () { return getTypeChecker().getRelationCacheSizes(); },
             getFileProcessingDiagnostics: function () { return fileProcessingDiagnostics; },
             getResolvedTypeReferenceDirectives: function () { return resolvedTypeReferenceDirectives; },
             isSourceFileFromExternalLibrary: isSourceFileFromExternalLibrary,
             isSourceFileDefaultLibrary: isSourceFileDefaultLibrary,
-            dropDiagnosticsProducingTypeChecker: dropDiagnosticsProducingTypeChecker,
             getSourceFileFromReference: getSourceFileFromReference,
             getLibFileFromReference: getLibFileFromReference,
             sourceFileToPackageName: sourceFileToPackageName,
@@ -96100,14 +96156,8 @@ var ts;
                 return ts.some(options.lib, function (libFileName) { return equalityComparer(file.fileName, pathForLibFile(libFileName)); });
             }
         }
-        function getDiagnosticsProducingTypeChecker() {
-            return diagnosticsProducingTypeChecker || (diagnosticsProducingTypeChecker = ts.createTypeChecker(program, true));
-        }
-        function dropDiagnosticsProducingTypeChecker() {
-            diagnosticsProducingTypeChecker = undefined;
-        }
         function getTypeChecker() {
-            return noDiagnosticsTypeChecker || (noDiagnosticsTypeChecker = ts.createTypeChecker(program, false));
+            return typeChecker || (typeChecker = ts.createTypeChecker(program));
         }
         function emit(sourceFile, writeFileCallback, cancellationToken, emitOnlyDtsFiles, transformers, forceDtsEmit) {
             ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("emit", "emit", { path: sourceFile === null || sourceFile === void 0 ? void 0 : sourceFile.path }, true);
@@ -96124,7 +96174,7 @@ var ts;
                 if (result)
                     return result;
             }
-            var emitResolver = getDiagnosticsProducingTypeChecker().getEmitResolver(ts.outFile(options) ? undefined : sourceFile, cancellationToken);
+            var emitResolver = getTypeChecker().getEmitResolver(ts.outFile(options) ? undefined : sourceFile, cancellationToken);
             ts.performance.mark("beforeEmit");
             var emitResult = ts.emitFiles(emitResolver, getEmitHost(writeFileCallback), sourceFile, ts.getTransformers(options, customTransformers, emitOnlyDtsFiles), emitOnlyDtsFiles, false, forceDtsEmit);
             ts.performance.mark("afterEmit");
@@ -96198,8 +96248,7 @@ var ts;
             }
             catch (e) {
                 if (e instanceof ts.OperationCanceledException) {
-                    noDiagnosticsTypeChecker = undefined;
-                    diagnosticsProducingTypeChecker = undefined;
+                    typeChecker = undefined;
                 }
                 throw e;
             }
@@ -96215,7 +96264,7 @@ var ts;
                 if (ts.skipTypeChecking(sourceFile, options, program)) {
                     return ts.emptyArray;
                 }
-                var typeChecker = getDiagnosticsProducingTypeChecker();
+                var typeChecker = getTypeChecker();
                 ts.Debug.assert(!!sourceFile.bindDiagnostics);
                 var isJs = sourceFile.scriptKind === 1 || sourceFile.scriptKind === 2;
                 var isCheckJs = isJs && ts.isCheckJsEnabledForFile(sourceFile, options);
@@ -96256,7 +96305,7 @@ var ts;
         }
         function getSuggestionDiagnostics(sourceFile, cancellationToken) {
             return runWithCancellationToken(function () {
-                return getDiagnosticsProducingTypeChecker().getSuggestionDiagnostics(sourceFile, cancellationToken);
+                return getTypeChecker().getSuggestionDiagnostics(sourceFile, cancellationToken);
             });
         }
         function markPrecedingCommentDirectiveLine(diagnostic, directives) {
@@ -96455,7 +96504,7 @@ var ts;
         }
         function getDeclarationDiagnosticsForFileNoCache(sourceFile, cancellationToken) {
             return runWithCancellationToken(function () {
-                var resolver = getDiagnosticsProducingTypeChecker().getEmitResolver(sourceFile, cancellationToken);
+                var resolver = getTypeChecker().getEmitResolver(sourceFile, cancellationToken);
                 return ts.getDeclarationDiagnostics(getEmitHost(ts.noop), resolver, sourceFile) || ts.emptyArray;
             });
         }
@@ -96492,7 +96541,7 @@ var ts;
             return diagnostics;
         }
         function getGlobalDiagnostics() {
-            return rootNames.length ? ts.sortAndDeduplicateDiagnostics(getDiagnosticsProducingTypeChecker().getGlobalDiagnostics().slice()) : ts.emptyArray;
+            return rootNames.length ? ts.sortAndDeduplicateDiagnostics(getTypeChecker().getGlobalDiagnostics().slice()) : ts.emptyArray;
         }
         function getConfigFileParsingDiagnostics() {
             return configFileParsingDiagnostics || ts.emptyArray;