typescript 4.7.0-dev.20220323 → 4.7.0-dev.20220325

package/lib/typescriptServices.js

@@ -294,7 +294,7 @@ var ts;
     // The following is baselined as a literal template type without intervention
     /** The version of the TypeScript compiler release */
     // eslint-disable-next-line @typescript-eslint/no-inferrable-types
-    ts.version = ts.versionMajorMinor + ".0-dev.20220323";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220325";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -8601,6 +8601,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}'.", /*reportsUnnecessary*/ undefined, /*elidedInCompatabilityPyramid*/ 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."),
@@ -44624,11 +44625,14 @@ var ts;
                 var saveExceptionTarget = currentExceptionTarget;
                 var saveActiveLabelList = activeLabelList;
                 var saveHasExplicitReturn = hasExplicitReturn;
-                var isIIFE = containerFlags & 16 /* IsFunctionExpression */ && !ts.hasSyntacticModifier(node, 256 /* Async */) &&
-                    !node.asteriskToken && !!ts.getImmediatelyInvokedFunctionExpression(node);
+                var isImmediatelyInvoked = (containerFlags & 16 /* IsFunctionExpression */ &&
+                    !ts.hasSyntacticModifier(node, 256 /* Async */) &&
+                    !node.asteriskToken &&
+                    !!ts.getImmediatelyInvokedFunctionExpression(node)) ||
+                    node.kind === 170 /* ClassStaticBlockDeclaration */;
                 // A non-async, non-generator IIFE is considered part of the containing control flow. Return statements behave
                 // similarly to break statements that exit to a label just past the statement body.
-                if (!isIIFE) {
+                if (!isImmediatelyInvoked) {
                     currentFlow = initFlowNode({ flags: 2 /* Start */ });
                     if (containerFlags & (16 /* IsFunctionExpression */ | 128 /* IsObjectLiteralOrClassExpressionMethodOrAccessor */)) {
                         currentFlow.node = node;
@@ -44636,7 +44640,7 @@ var ts;
                 }
                 // We create a return control flow graph for IIFEs and constructors. For constructors
                 // we use the return control flow graph in strict property initialization checks.
-                currentReturnTarget = isIIFE || node.kind === 171 /* Constructor */ || node.kind === 170 /* ClassStaticBlockDeclaration */ || (ts.isInJSFile(node) && (node.kind === 256 /* FunctionDeclaration */ || node.kind === 213 /* FunctionExpression */)) ? createBranchLabel() : undefined;
+                currentReturnTarget = isImmediatelyInvoked || node.kind === 171 /* Constructor */ || (ts.isInJSFile(node) && (node.kind === 256 /* FunctionDeclaration */ || node.kind === 213 /* FunctionExpression */)) ? createBranchLabel() : undefined;
                 currentExceptionTarget = undefined;
                 currentBreakTarget = undefined;
                 currentContinueTarget = undefined;
@@ -44662,7 +44666,7 @@ var ts;
                         node.returnFlowNode = currentFlow;
                     }
                 }
-                if (!isIIFE) {
+                if (!isImmediatelyInvoked) {
                     currentFlow = saveCurrentFlow;
                 }
                 currentBreakTarget = saveBreakTarget;
@@ -47708,7 +47712,7 @@ var ts;
             (preserveConstEnums && moduleState === 2 /* ConstEnumOnly */);
     }
     ts.isInstantiatedModule = isInstantiatedModule;
-    function createTypeChecker(host, produceDiagnostics) {
+    function createTypeChecker(host) {
         var getPackagesMap = ts.memoize(function () {
             // A package name maps to true when we detect it has .d.ts files.
             // This is useful as an approximation of whether a package bundles its own types.
@@ -47725,6 +47729,10 @@ var ts;
             });
             return map;
         });
+        var deferredDiagnosticsCallbacks = [];
+        var addLazyDiagnostic = function (arg) {
+            deferredDiagnosticsCallbacks.push(arg);
+        };
         // Cancellation that controls whether or not we can cancel in the middle of type checking.
         // In general cancelling is *not* safe for the type checker.  We might be in the middle of
         // computing something, and we will leave our internals in an inconsistent state.  Callers
@@ -48088,8 +48096,8 @@ var ts;
                     // Do this in a finally block so we can ensure that it gets reset back to nothing after
                     // this call is done.
                     cancellationToken = ct;
-                    // Ensure file is type checked
-                    checkSourceFile(file);
+                    // Ensure file is type checked, with _eager_ diagnostic production, so identifiers are registered as potentially unused
+                    checkSourceFileWithEagerDiagnostics(file);
                     ts.Debug.assert(!!(getNodeLinks(file).flags & 1 /* TypeChecked */));
                     diagnostics = ts.addRange(diagnostics, suggestionDiagnostics.getDiagnostics(file.fileName));
                     checkUnusedIdentifiers(getPotentiallyUnusedIdentifiers(file), function (containingNode, kind, diag) {
@@ -49425,110 +49433,114 @@ var ts;
                 }
             }
             if (!result) {
-                if (nameNotFoundMessage && produceDiagnostics) {
-                    if (!errorLocation ||
-                        !checkAndReportErrorForMissingPrefix(errorLocation, name, nameArg) && // TODO: GH#18217
-                            !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, /*excludeClasses*/ false);
-                                var message = meaning === 1920 /* Namespace */ || 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) && // TODO: GH#18217
+                                !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, /*excludeClasses*/ false);
+                                    var message = meaning === 1920 /* Namespace */ || 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 (propertyWithInvalidInitializer && !(ts.getEmitScriptTarget(compilerOptions) === 99 /* ESNext */ && useDefineForClassFields)) {
+                // We have a match, but the reference occurred within a property initializer and the identifier also binds
+                // to a local variable in the constructor where the code will be emitted. Note that this is actually allowed
+                // with ESNext+useDefineForClassFields because the scope semantics are different.
+                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;
+            }
             // Perform extra checks only if error reporting was requested
-            if (nameNotFoundMessage && produceDiagnostics) {
-                if (propertyWithInvalidInitializer && !(ts.getEmitScriptTarget(compilerOptions) === 99 /* ESNext */ && useDefineForClassFields)) {
-                    // We have a match, but the reference occurred within a property initializer and the identifier also binds
-                    // to a local variable in the constructor where the code will be emitted. Note that this is actually allowed
-                    // with ESNext+useDefineForClassFields because the scope semantics are different.
-                    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;
-                }
-                // Only check for block-scoped variable if we have an error location and are looking for the
-                // name with variable meaning
-                //      For example,
-                //          declare module foo {
-                //              interface bar {}
-                //          }
-                //      const foo/*1*/: foo/*2*/.bar;
-                // The foo at /*1*/ and /*2*/ will share same symbol with two meanings:
-                // block-scoped variable and namespace module. However, only when we
-                // try to resolve name in /*1*/ which is used in variable position,
-                // we want to check for block-scoped
-                if (errorLocation &&
-                    (meaning & 2 /* BlockScopedVariable */ ||
-                        ((meaning & 32 /* Class */ || meaning & 384 /* Enum */) && (meaning & 111551 /* Value */) === 111551 /* Value */))) {
-                    var exportOrLocalSymbol = getExportSymbolOfValueSymbolIfExported(result);
-                    if (exportOrLocalSymbol.flags & 2 /* BlockScopedVariable */ || exportOrLocalSymbol.flags & 32 /* Class */ || exportOrLocalSymbol.flags & 384 /* Enum */) {
-                        checkResolvedBlockScopedVariable(exportOrLocalSymbol, errorLocation);
-                    }
-                }
-                // If we're in an external module, we can't reference value symbols created from UMD export declarations
-                if (result && isInExternalModule && (meaning & 111551 /* Value */) === 111551 /* Value */ && !(originalLocation.flags & 4194304 /* JSDoc */)) {
-                    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 we're in a parameter initializer or binding name, we can't reference the values of the parameter whose initializer we're within or parameters to the right
-                if (result && associatedDeclarationForContainingInitializerOrBindingName && !withinDeferredContext && (meaning & 111551 /* Value */) === 111551 /* Value */) {
-                    var candidate = getMergedSymbol(getLateBoundSymbol(result));
-                    var root = ts.getRootDeclaration(associatedDeclarationForContainingInitializerOrBindingName);
-                    // A parameter initializer or binding pattern initializer within a parameter cannot refer to itself
-                    if (candidate === getSymbolOfNode(associatedDeclarationForContainingInitializerOrBindingName)) {
-                        error(errorLocation, ts.Diagnostics.Parameter_0_cannot_reference_itself, ts.declarationNameToString(associatedDeclarationForContainingInitializerOrBindingName.name));
-                    }
-                    // And it cannot refer to any declarations which come after it
-                    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 /* Value */ && result.flags & 2097152 /* Alias */ && !(result.flags & 111551 /* Value */) && !ts.isValidTypeOnlyAliasUseSite(errorLocation)) {
-                    var typeOnlyDeclaration = getTypeOnlyAliasDeclaration(result);
-                    if (typeOnlyDeclaration) {
-                        var message = typeOnlyDeclaration.kind === 275 /* ExportSpecifier */
-                            ? 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 (nameNotFoundMessage) {
+                addLazyDiagnostic(function () {
+                    // Only check for block-scoped variable if we have an error location and are looking for the
+                    // name with variable meaning
+                    //      For example,
+                    //          declare module foo {
+                    //              interface bar {}
+                    //          }
+                    //      const foo/*1*/: foo/*2*/.bar;
+                    // The foo at /*1*/ and /*2*/ will share same symbol with two meanings:
+                    // block-scoped variable and namespace module. However, only when we
+                    // try to resolve name in /*1*/ which is used in variable position,
+                    // we want to check for block-scoped
+                    if (errorLocation &&
+                        (meaning & 2 /* BlockScopedVariable */ ||
+                            ((meaning & 32 /* Class */ || meaning & 384 /* Enum */) && (meaning & 111551 /* Value */) === 111551 /* Value */))) {
+                        var exportOrLocalSymbol = getExportSymbolOfValueSymbolIfExported(result);
+                        if (exportOrLocalSymbol.flags & 2 /* BlockScopedVariable */ || exportOrLocalSymbol.flags & 32 /* Class */ || exportOrLocalSymbol.flags & 384 /* Enum */) {
+                            checkResolvedBlockScopedVariable(exportOrLocalSymbol, errorLocation);
+                        }
+                    }
+                    // If we're in an external module, we can't reference value symbols created from UMD export declarations
+                    if (result && isInExternalModule && (meaning & 111551 /* Value */) === 111551 /* Value */ && !(originalLocation.flags & 4194304 /* JSDoc */)) {
+                        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 we're in a parameter initializer or binding name, we can't reference the values of the parameter whose initializer we're within or parameters to the right
+                    if (result && associatedDeclarationForContainingInitializerOrBindingName && !withinDeferredContext && (meaning & 111551 /* Value */) === 111551 /* Value */) {
+                        var candidate = getMergedSymbol(getLateBoundSymbol(result));
+                        var root = ts.getRootDeclaration(associatedDeclarationForContainingInitializerOrBindingName);
+                        // A parameter initializer or binding pattern initializer within a parameter cannot refer to itself
+                        if (candidate === getSymbolOfNode(associatedDeclarationForContainingInitializerOrBindingName)) {
+                            error(errorLocation, ts.Diagnostics.Parameter_0_cannot_reference_itself, ts.declarationNameToString(associatedDeclarationForContainingInitializerOrBindingName.name));
+                        }
+                        // And it cannot refer to any declarations which come after it
+                        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 /* Value */ && result.flags & 2097152 /* Alias */ && !(result.flags & 111551 /* Value */) && !ts.isValidTypeOnlyAliasUseSite(errorLocation)) {
+                        var typeOnlyDeclaration = getTypeOnlyAliasDeclaration(result);
+                        if (typeOnlyDeclaration) {
+                            var message = typeOnlyDeclaration.kind === 275 /* ExportSpecifier */
+                                ? 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;
         }
@@ -51174,9 +51186,7 @@ var ts;
             var result = new Type(checker, flags);
             typeCount++;
             result.id = typeCount;
-            if (produceDiagnostics) { // Only record types from one checker
-                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) {
@@ -64510,6 +64520,7 @@ var ts;
                 return 0 /* False */;
             }
             function reportErrorResults(originalSource, originalTarget, source, target, headMessage) {
+                var _a, _b;
                 var sourceHasBase = !!getSingleBaseForNonAugmentingSubtype(originalSource);
                 var targetHasBase = !!getSingleBaseForNonAugmentingSubtype(originalTarget);
                 source = (originalSource.aliasSymbol || sourceHasBase) ? originalSource : source;
@@ -64550,6 +64561,9 @@ var ts;
                     return;
                 }
                 reportRelationError(headMessage, source, target);
+                if (strictNullChecks && source.flags & 8650752 /* TypeVariable */ && ((_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 /* NonPrimitive */))) {
+                    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) {
@@ -65322,7 +65336,7 @@ var ts;
                     // IndexedAccess comparisons are handled above in the `targetFlags & TypeFlage.IndexedAccess` branch
                     if (!(sourceFlags & 8388608 /* IndexedAccess */ && targetFlags & 8388608 /* IndexedAccess */)) {
                         var constraint = getConstraintOfType(source);
-                        if (!constraint || (sourceFlags & 262144 /* TypeParameter */ && constraint.flags & 1 /* Any */)) {
+                        if (!strictNullChecks && (!constraint || (sourceFlags & 262144 /* TypeParameter */ && constraint.flags & 1 /* Any */))) {
                             // A type variable with no constraint is not related to the non-primitive object type.
                             if (result = isRelatedTo(emptyObjectType, extractTypesOfKind(target, ~67108864 /* NonPrimitive */), 3 /* Both */)) {
                                 resetErrorInfo(saveErrorInfo);
@@ -65330,12 +65344,12 @@ var ts;
                             }
                         }
                         // hi-speed no-this-instantiation check (less accurate, but avoids costly `this`-instantiation when the constraint will suffice), see #28231 for report on why this is needed
-                        else if (result = isRelatedTo(constraint, target, 1 /* Source */, /*reportErrors*/ false, /*headMessage*/ undefined, intersectionState)) {
+                        else if (constraint && (result = isRelatedTo(constraint, target, 1 /* Source */, /*reportErrors*/ false, /*headMessage*/ undefined, intersectionState))) {
                             resetErrorInfo(saveErrorInfo);
                             return result;
                         }
                         // slower, fuller, this-instantiated check (necessary when comparing raw `this` types from base classes), see `subclassWithPolymorphicThisIsAssignable.ts` test for example
-                        else if (result = isRelatedTo(getTypeWithThisArgument(constraint, source), target, 1 /* Source */, reportErrors && !(targetFlags & sourceFlags & 262144 /* TypeParameter */), /*headMessage*/ undefined, intersectionState)) {
+                        else if (constraint && (result = isRelatedTo(getTypeWithThisArgument(constraint, source), target, 1 /* Source */, reportErrors && !(targetFlags & sourceFlags & 262144 /* TypeParameter */), /*headMessage*/ undefined, intersectionState))) {
                             resetErrorInfo(saveErrorInfo);
                             return result;
                         }
@@ -67394,12 +67408,14 @@ var ts;
             errorOrSuggestion(noImplicitAny, declaration, diagnostic, ts.declarationNameToString(ts.getNameOfDeclaration(declaration)), typeAsString);
         }
         function reportErrorsFromWidening(declaration, type, wideningKind) {
-            if (produceDiagnostics && noImplicitAny && ts.getObjectFlags(type) & 65536 /* ContainsWideningType */ && (!wideningKind || !getContextualSignatureForFunctionLikeDeclaration(declaration))) {
-                // Report implicit any error within type if possible, otherwise report error on declaration
-                if (!reportWideningErrorsInType(type)) {
-                    reportImplicitAny(declaration, type, wideningKind);
+            addLazyDiagnostic(function () {
+                if (noImplicitAny && ts.getObjectFlags(type) & 65536 /* ContainsWideningType */ && (!wideningKind || !getContextualSignatureForFunctionLikeDeclaration(declaration))) {
+                    // Report implicit any error within type if possible, otherwise report error on declaration
+                    if (!reportWideningErrorsInType(type)) {
+                        reportImplicitAny(declaration, type, wideningKind);
+                    }
                 }
-            }
+            });
         }
         function applyToParameterTypes(source, target, callback) {
             var sourceCount = getParameterCount(source);
@@ -74162,6 +74178,7 @@ var ts;
                 && !isOptionalPropertyDeclaration(valueDeclaration)
                 && !(ts.isAccessExpression(node) && ts.isAccessExpression(node.expression))
                 && !isBlockScopedNameDeclaredBeforeUse(valueDeclaration, right)
+                && !(ts.isMethodDeclaration(valueDeclaration) && ts.getCombinedModifierFlags(valueDeclaration) & 32 /* Static */)
                 && (compilerOptions.useDefineForClassFields || !isPropertyDeclaredInAncestorClass(prop))) {
                 diagnosticMessage = error(right, ts.Diagnostics.Property_0_is_used_before_its_initialization, declarationName);
             }
@@ -75391,7 +75408,7 @@ var ts;
             var isTaggedTemplate = node.kind === 210 /* TaggedTemplateExpression */;
             var isDecorator = node.kind === 165 /* Decorator */;
             var isJsxOpeningOrSelfClosingElement = ts.isJsxOpeningLikeElement(node);
-            var reportErrors = !candidatesOutArray && produceDiagnostics;
+            var reportErrors = !candidatesOutArray;
             var typeArguments;
             if (!isDecorator) {
                 typeArguments = node.typeArguments;
@@ -76671,11 +76688,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;
         }
@@ -77435,47 +77454,48 @@ var ts;
          * @param returnType - return type of the function, can be undefined if return type is not explicitly specified
          */
         function checkAllCodePathsInNonVoidFunctionReturnOrThrow(func, returnType) {
-            if (!produceDiagnostics) {
-                return;
-            }
-            var functionFlags = ts.getFunctionFlags(func);
-            var type = returnType && unwrapReturnType(returnType, functionFlags);
-            // Functions with with an explicitly specified 'void' or 'any' return type don't need any return expressions.
-            if (type && maybeTypeOfKind(type, 1 /* Any */ | 16384 /* Void */)) {
-                return;
-            }
-            // If all we have is a function signature, or an arrow function with an expression body, then there is nothing to check.
-            // also if HasImplicitReturn flag is not set this means that all codepaths in function body end with return or throw
-            if (func.kind === 168 /* MethodSignature */ || ts.nodeIsMissing(func.body) || func.body.kind !== 235 /* Block */ || !functionHasImplicitReturn(func)) {
-                return;
-            }
-            var hasExplicitReturn = func.flags & 512 /* HasExplicitReturn */;
-            var errorNode = ts.getEffectiveReturnTypeNode(func) || func;
-            if (type && type.flags & 131072 /* Never */) {
-                error(errorNode, ts.Diagnostics.A_function_returning_never_cannot_have_a_reachable_end_point);
-            }
-            else if (type && !hasExplicitReturn) {
-                // minimal check: function has syntactic return type annotation and no explicit return statements in the body
-                // this function does not conform to the specification.
-                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 return type annotation is omitted check if function has any explicit return statements.
-                    // If it does not have any - its inferred return type is void - don't do any checks.
-                    // Otherwise get inferred return type from function body and report error only if it is not void / anytype
-                    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);
+                // Functions with with an explicitly specified 'void' or 'any' return type don't need any return expressions.
+                if (type && maybeTypeOfKind(type, 1 /* Any */ | 16384 /* Void */)) {
+                    return;
+                }
+                // If all we have is a function signature, or an arrow function with an expression body, then there is nothing to check.
+                // also if HasImplicitReturn flag is not set this means that all codepaths in function body end with return or throw
+                if (func.kind === 168 /* MethodSignature */ || ts.nodeIsMissing(func.body) || func.body.kind !== 235 /* Block */ || !functionHasImplicitReturn(func)) {
+                    return;
+                }
+                var hasExplicitReturn = func.flags & 512 /* HasExplicitReturn */;
+                var errorNode = ts.getEffectiveReturnTypeNode(func) || func;
+                if (type && type.flags & 131072 /* Never */) {
+                    error(errorNode, ts.Diagnostics.A_function_returning_never_cannot_have_a_reachable_end_point);
+                }
+                else if (type && !hasExplicitReturn) {
+                    // minimal check: function has syntactic return type annotation and no explicit return statements in the body
+                    // this function does not conform to the specification.
+                    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 return type annotation is omitted check if function has any explicit return statements.
+                        // If it does not have any - its inferred return type is void - don't do any checks.
+                        // Otherwise get inferred return type from function body and report error only if it is not void / anytype
+                        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) {
@@ -77735,49 +77755,50 @@ var ts;
             checkExpression(node.expression);
             return undefinedWideningType;
         }
-        function checkAwaitExpression(node) {
+        function checkAwaitExpressionGrammar(node) {
             // Grammar checking
-            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 /* AwaitContext */)) {
-                    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 /* ES2017 */) {
+            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 /* AwaitContext */)) {
+                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 {
-                        // use of 'await' in non-async function
-                        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 /* Constructor */ && (ts.getFunctionFlags(container) & 2 /* Async */) === 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 /* ES2017 */) {
+                            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 {
+                    // use of 'await' in non-async function
+                    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 /* Constructor */ && (ts.getFunctionFlags(container) & 2 /* Async */) === 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, /*withAlias*/ 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 /* AnyOrUnknown */)) {
@@ -78601,7 +78622,10 @@ var ts;
                 }
             }
             function checkAssignmentOperator(valueType) {
-                if (produceDiagnostics && ts.isAssignmentOperator(operator)) {
+                if (ts.isAssignmentOperator(operator)) {
+                    addLazyDiagnostic(checkAssignmentOperatorWorker);
+                }
+                function checkAssignmentOperatorWorker() {
                     // TypeScript 1.0 spec (April 2014): 4.17
                     // An assignment of the form
                     //    VarExpr = ValueExpr
@@ -78700,15 +78724,7 @@ var ts;
             return [effectiveLeft, effectiveRight];
         }
         function checkYieldExpression(node) {
-            // Grammar checking
-            if (produceDiagnostics) {
-                if (!(node.flags & 8192 /* YieldContext */)) {
-                    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;
@@ -78754,14 +78770,24 @@ var ts;
             var type = getContextualIterationType(2 /* Next */, 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 /* YieldContext */)) {
+                    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);
@@ -79357,9 +79383,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) {
             // Grammar checking
@@ -79513,7 +79537,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) {
@@ -79803,9 +79828,8 @@ var ts;
             if (ts.nodeIsMissing(node.body)) {
                 return;
             }
-            if (!produceDiagnostics) {
-                return;
-            }
+            addLazyDiagnostic(checkConstructorDeclarationDiagnostics);
+            return;
             function isInstancePropertyWithInitializerOrPrivateIdentifierProperty(n) {
                 if (ts.isPrivateIdentifierClassElementDeclaration(n)) {
                     return true;
@@ -79814,54 +79838,56 @@ var ts;
                     !ts.isStatic(n) &&
                     !!n.initializer;
             }
-            // TS 1.0 spec (April 2014): 8.3.2
-            // Constructors of classes with no extends clause may not contain super calls, whereas
-            // constructors of derived classes must contain at least one super call somewhere in their function body.
-            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);
-                    }
-                    // A super call must be root-level in a constructor if both of the following are true:
-                    // - The containing class is a derived class.
-                    // - The constructor declares parameter properties
-                    //   or the containing class declares instance member variables with initializers.
-                    var superCallShouldBeRootLevel = (ts.getEmitScriptTarget(compilerOptions) !== 99 /* ESNext */ || !useDefineForClassFields) &&
-                        (ts.some(node.parent.members, isInstancePropertyWithInitializerOrPrivateIdentifierProperty) ||
-                            ts.some(node.parameters, function (p) { return ts.hasSyntacticModifier(p, 16476 /* ParameterPropertyModifier */); }));
-                    if (superCallShouldBeRootLevel) {
-                        // Until we have better flow analysis, it is an error to place the super call within any kind of block or conditional
-                        // See GH #8277
-                        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);
-                        }
-                        // Skip past any prologue directives to check statements for referring to 'super' or 'this' before a super call
-                        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;
-                                }
-                            }
+            function checkConstructorDeclarationDiagnostics() {
+                // TS 1.0 spec (April 2014): 8.3.2
+                // Constructors of classes with no extends clause may not contain super calls, whereas
+                // constructors of derived classes must contain at least one super call somewhere in their function body.
+                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);
+                        }
+                        // A super call must be root-level in a constructor if both of the following are true:
+                        // - The containing class is a derived class.
+                        // - The constructor declares parameter properties
+                        //   or the containing class declares instance member variables with initializers.
+                        var superCallShouldBeRootLevel = (ts.getEmitScriptTarget(compilerOptions) !== 99 /* ESNext */ || !useDefineForClassFields) &&
+                            (ts.some(node.parent.members, isInstancePropertyWithInitializerOrPrivateIdentifierProperty) ||
+                                ts.some(node.parameters, function (p) { return ts.hasSyntacticModifier(p, 16476 /* ParameterPropertyModifier */); }));
+                        if (superCallShouldBeRootLevel) {
                             // Until we have better flow analysis, it is an error to place the super call within any kind of block or conditional
                             // See GH #8277
-                            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 (!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);
+                            }
+                            // Skip past any prologue directives to check statements for referring to 'super' or 'this' before a super call
+                            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;
+                                    }
+                                }
+                                // Until we have better flow analysis, it is an error to place the super call within any kind of block or conditional
+                                // See GH #8277
+                                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);
+                    }
                 }
             }
         }
@@ -79879,7 +79905,10 @@ var ts;
             return !!ts.forEachChild(node, nodeImmediatelyReferencesSuperOrThis);
         }
         function checkAccessorDeclaration(node) {
-            if (produceDiagnostics) {
+            addLazyDiagnostic(checkAccessorDeclarationDiagnostics);
+            checkSourceElement(node.body);
+            setNodeLinksForPrivateIdentifierScope(node);
+            function checkAccessorDeclarationDiagnostics() {
                 // Grammar checking accessors
                 if (!checkGrammarFunctionLikeDeclaration(node) && !checkGrammarAccessor(node))
                     checkGrammarComputedPropertyName(node.name);
@@ -79929,8 +79958,6 @@ var ts;
                     checkAllCodePathsInNonVoidFunctionReturnOrThrow(node, returnType);
                 }
             }
-            checkSourceElement(node.body);
-            setNodeLinksForPrivateIdentifierScope(node);
         }
         function checkMissingDeclaration(node) {
             checkDecorators(node);
@@ -79973,11 +80000,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) {
@@ -80005,7 +80034,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);
@@ -80196,9 +80226,9 @@ var ts;
             return flags & flagsToCheck;
         }
         function checkFunctionOrConstructorSymbol(symbol) {
-            if (!produceDiagnostics) {
-                return;
-            }
+            addLazyDiagnostic(function () { return checkFunctionOrConstructorSymbolWorker(symbol); });
+        }
+        function checkFunctionOrConstructorSymbolWorker(symbol) {
             function getCanonicalOverload(overloads, implementation) {
                 // Consider the canonical set of flags to be the flags of the bodyDeclaration or the first declaration
                 // Error on all deviations from this canonical set of flags
@@ -80419,9 +80449,9 @@ var ts;
             }
         }
         function checkExportsOnMergedDeclarations(node) {
-            if (!produceDiagnostics) {
-                return;
-            }
+            addLazyDiagnostic(function () { return checkExportsOnMergedDeclarationsWorker(node); });
+        }
+        function checkExportsOnMergedDeclarationsWorker(node) {
             // if localSymbol is defined on node then node itself is exported - check is required
             var symbol = node.localSymbol;
             if (!symbol) {
@@ -81065,7 +81095,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);
@@ -81099,10 +81130,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);
@@ -81183,19 +81217,7 @@ var ts;
             var body = node.kind === 168 /* MethodSignature */ ? undefined : node.body;
             checkSourceElement(body);
             checkAllCodePathsInNonVoidFunctionReturnOrThrow(node, getReturnTypeFromAnnotation(node));
-            if (produceDiagnostics && !ts.getEffectiveReturnTypeNode(node)) {
-                // Report an implicit any error if there is no body, no explicit return type, and node is not a private method
-                // in an ambient context
-                if (ts.nodeIsMissing(body) && !isPrivateWithinAmbient(node)) {
-                    reportImplicitAny(node, anyType);
-                }
-                if (functionFlags & 1 /* Generator */ && ts.nodeIsPresent(body)) {
-                    // A generator with a body and no type annotation can still cause errors. It can error if the
-                    // yielded values have no common supertype, or it can give an implicit any error if it has no
-                    // yielded values. The only way to trigger these errors is to try checking its return type.
-                    getReturnTypeOfSignature(getSignatureFromDeclaration(node));
-                }
-            }
+            addLazyDiagnostic(checkFunctionOrMethodDeclarationDiagnostics);
             // A js function declaration can have a @type tag instead of a return type node, but that type must have a call signature
             if (ts.isInJSFile(node)) {
                 var typeTag = ts.getJSDocTypeTag(node);
@@ -81203,10 +81225,26 @@ var ts;
                     error(typeTag.typeExpression.type, ts.Diagnostics.The_type_of_a_function_declaration_must_match_the_function_s_signature);
                 }
             }
+            function checkFunctionOrMethodDeclarationDiagnostics() {
+                if (!ts.getEffectiveReturnTypeNode(node)) {
+                    // Report an implicit any error if there is no body, no explicit return type, and node is not a private method
+                    // in an ambient context
+                    if (ts.nodeIsMissing(body) && !isPrivateWithinAmbient(node)) {
+                        reportImplicitAny(node, anyType);
+                    }
+                    if (functionFlags & 1 /* Generator */ && ts.nodeIsPresent(body)) {
+                        // A generator with a body and no type annotation can still cause errors. It can error if the
+                        // yielded values have no common supertype, or it can give an implicit any error if it has no
+                        // yielded values. The only way to trigger these errors is to try checking its return type.
+                        getReturnTypeOfSignature(getSignatureFromDeclaration(node));
+                    }
+                }
+            }
         }
         function registerForUnusedIdentifiersCheck(node) {
-            // May be in a call such as getTypeOfNode that happened to call this. But potentiallyUnusedIdentifiers is only defined in the scope of `checkSourceFile`.
-            if (produceDiagnostics) {
+            addLazyDiagnostic(registerForUnusedIdentifiersCheckDiagnostics);
+            function registerForUnusedIdentifiersCheckDiagnostics() {
+                // May be in a call such as getTypeOfNode that happened to call this. But potentiallyUnusedIdentifiers is only defined in the scope of `checkSourceFile`.
                 var sourceFile = ts.getSourceFileOfNode(node);
                 var potentiallyUnusedIdentifiers = allPotentiallyUnusedIdentifiers.get(sourceFile.path);
                 if (!potentiallyUnusedIdentifiers) {
@@ -82980,26 +83018,31 @@ var ts;
                         hasDuplicateDefaultClause = true;
                     }
                 }
-                if (produceDiagnostics && clause.kind === 289 /* CaseClause */) {
-                    // TypeScript 1.0 spec (April 2014): 5.9
-                    // In a 'switch' statement, each 'case' expression must be of a type that is comparable
-                    // to or from the type of the 'switch' expression.
-                    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)) {
-                        // expressionType is not comparable to caseType, try the reversed check and report errors if it fails
-                        checkTypeComparableTo(caseType, comparedExpressionType, clause.expression, /*headMessage*/ undefined);
-                    }
+                if (clause.kind === 289 /* CaseClause */) {
+                    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 () {
+                        // TypeScript 1.0 spec (April 2014): 5.9
+                        // In a 'switch' statement, each 'case' expression must be of a type that is comparable
+                        // to or from the type of the 'switch' expression.
+                        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)) {
+                            // expressionType is not comparable to caseType, try the reversed check and report errors if it fails
+                            checkTypeComparableTo(caseType, comparedExpressionType, clause.expression, /*headMessage*/ undefined);
+                        }
+                    };
+                }
             });
             if (node.caseBlock.locals) {
                 registerForUnusedIdentifiersCheck(node.caseBlock);
@@ -83220,26 +83263,29 @@ var ts;
          * Check each type parameter and check that type parameters have no duplicate type parameter declarations
          */
         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));
                         }
                     }
-                }
+                };
             }
         }
         /** Check that type parameter defaults only reference previously declared type parameters */
@@ -83371,85 +83417,90 @@ 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, /*errorNode*/ undefined)) {
-                        issueMemberSpecificError(node, typeWithThis, baseWithThis, ts.Diagnostics.Class_0_incorrectly_extends_base_class_1);
-                    }
-                    else {
-                        // Report static side error only when instance type is assignable
-                        checkTypeAssignableTo(staticType, getTypeWithoutSignatures(staticBaseType), node.name || node, ts.Diagnostics.Class_static_side_0_incorrectly_extends_base_class_static_side_1);
-                    }
-                    if (baseConstructorType.flags & 8650752 /* TypeVariable */) {
-                        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, /*errorNode*/ undefined)) {
+                            issueMemberSpecificError(node, typeWithThis, baseWithThis, ts.Diagnostics.Class_0_incorrectly_extends_base_class_1);
                         }
                         else {
-                            var constructSignatures = getSignaturesOfType(baseConstructorType, 1 /* Construct */);
-                            if (constructSignatures.some(function (signature) { return signature.flags & 4 /* Abstract */; }) && !ts.hasSyntacticModifier(node, 128 /* Abstract */)) {
-                                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);
+                            // Report static side error only when instance type is assignable
+                            checkTypeAssignableTo(staticType, getTypeWithoutSignatures(staticBaseType), node.name || node, ts.Diagnostics.Class_static_side_0_incorrectly_extends_base_class_static_side_1);
+                        }
+                        if (baseConstructorType.flags & 8650752 /* TypeVariable */) {
+                            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 /* Construct */);
+                                if (constructSignatures.some(function (signature) { return signature.flags & 4 /* Abstract */; }) && !ts.hasSyntacticModifier(node, 128 /* Abstract */)) {
+                                    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 /* Class */) && !(baseConstructorType.flags & 8650752 /* TypeVariable */)) {
-                        // When the static base type is a "class-like" constructor function (but not actually a class), we verify
-                        // that all instantiated base constructor signatures return the same type.
-                        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 /* Class */) && !(baseConstructorType.flags & 8650752 /* TypeVariable */)) {
+                            // When the static base type is a "class-like" constructor function (but not actually a class), we verify
+                            // that all instantiated base constructor signatures return the same type.
+                            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 /* Class */ ?
-                                    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, /*errorNode*/ 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, /*isStaticIndex*/ 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 /* Class */ ?
+                                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, /*errorNode*/ 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) {
@@ -83773,8 +83824,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];
@@ -83796,8 +83847,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];
@@ -83881,7 +83932,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);
@@ -83901,7 +83952,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);
@@ -83909,10 +83960,10 @@ var ts;
                 checkTypeReferenceNode(heritageElement);
             });
             ts.forEach(node.members, checkSourceElement);
-            if (produceDiagnostics) {
+            addLazyDiagnostic(function () {
                 checkTypeForDuplicateIndexSignatures(node);
                 registerForUnusedIdentifiersCheck(node);
-            }
+            });
         }
         function checkTypeAliasDeclaration(node) {
             // Grammar checking
@@ -84101,9 +84152,9 @@ var ts;
                     ts.isStringLiteralLike(node.argumentExpression);
         }
         function checkEnumDeclaration(node) {
-            if (!produceDiagnostics) {
-                return;
-            }
+            addLazyDiagnostic(function () { return checkEnumDeclarationWorker(node); });
+        }
+        function checkEnumDeclarationWorker(node) {
             // Grammar checking
             checkGrammarDecoratorsAndModifiers(node);
             checkCollisionsForDeclarationName(node, node.name);
@@ -84183,7 +84234,14 @@ var ts;
             }
         }
         function checkModuleDeclaration(node) {
-            if (produceDiagnostics) {
+            if (node.body) {
+                checkSourceElement(node.body);
+                if (!ts.isGlobalScopeAugmentation(node)) {
+                    registerForUnusedIdentifiersCheck(node);
+                }
+            }
+            addLazyDiagnostic(checkModuleDeclarationDiagnostics);
+            function checkModuleDeclarationDiagnostics() {
                 // Grammar checking
                 var isGlobalAugmentation = ts.isGlobalScopeAugmentation(node);
                 var inAmbientContext = node.flags & 8388608 /* Ambient */;
@@ -84266,12 +84324,6 @@ var ts;
                     }
                 }
             }
-            if (node.body) {
-                checkSourceElement(node.body);
-                if (!ts.isGlobalScopeAugmentation(node)) {
-                    registerForUnusedIdentifiersCheck(node);
-                }
-            }
         }
         function checkModuleAugmentationElement(node, isGlobalAugmentation) {
             var _a;
@@ -85208,13 +85260,16 @@ 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 /* Ambient */))) {
-                            diagnostics.add(diag);
-                        }
-                    });
-                }
+                addLazyDiagnostic(function () {
+                    // This relies on the results of other lazy diagnostics, so must be computed after them
+                    if (!node.isDeclarationFile && (compilerOptions.noUnusedLocals || compilerOptions.noUnusedParameters)) {
+                        checkUnusedIdentifiers(getPotentiallyUnusedIdentifiers(node), function (containingNode, kind, diag) {
+                            if (!ts.containsParseError(containingNode) && unusedIsError(kind, !!(containingNode.flags & 8388608 /* Ambient */))) {
+                                diagnostics.add(diag);
+                            }
+                        });
+                    }
+                });
                 if (compilerOptions.importsNotUsedAsValues === 2 /* Error */ &&
                     !node.isDeclarationFile &&
                     ts.isExternalModule(node)) {
@@ -85254,15 +85309,35 @@ var ts;
                 cancellationToken = undefined;
             }
         }
+        function ensurePendingDiagnosticWorkComplete() {
+            // Invoke any existing lazy diagnostics to add them, clear the backlog of diagnostics
+            for (var _i = 0, deferredDiagnosticsCallbacks_1 = deferredDiagnosticsCallbacks; _i < deferredDiagnosticsCallbacks_1.length; _i++) {
+                var cb = deferredDiagnosticsCallbacks_1[_i];
+                cb();
+            }
+            deferredDiagnosticsCallbacks = [];
+        }
+        function checkSourceFileWithEagerDiagnostics(sourceFile) {
+            ensurePendingDiagnosticWorkComplete();
+            // then setup diagnostics for immediate invocation (as we are about to collect them, and
+            // this avoids the overhead of longer-lived callbacks we don't need to allocate)
+            // This also serves to make the shift to possibly lazy diagnostics transparent to serial command-line scenarios
+            // (as in those cases, all the diagnostics will still be computed as the appropriate place in the tree,
+            // thus much more likely retaining the same union ordering as before we had lazy diagnostics)
+            var oldAddLazyDiagnostics = addLazyDiagnostic;
+            addLazyDiagnostic = function (cb) { return cb(); };
+            checkSourceFile(sourceFile);
+            addLazyDiagnostic = oldAddLazyDiagnostics;
+        }
         function getDiagnosticsWorker(sourceFile) {
-            throwIfNonDiagnosticsProducing();
             if (sourceFile) {
+                ensurePendingDiagnosticWorkComplete();
                 // Some global diagnostics are deferred until they are needed and
                 // may not be reported in the first call to getGlobalDiagnostics.
                 // We should catch these changes and report them.
                 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) {
@@ -85280,18 +85355,13 @@ var ts;
             }
             // Global diagnostics are always added when a file is not provided to
             // getDiagnostics
-            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.");
-            }
-        }
         // Language service support
         function getSymbolsInScope(location, meaning) {
             if (location.flags & 16777216 /* InWithStatement */) {
@@ -115765,8 +115835,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();
@@ -116012,21 +116081,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,
@@ -116615,14 +116682,8 @@ var ts;
                 return ts.some(options.lib, function (libFileName) { return equalityComparer(file.fileName, pathForLibFile(libFileName)); });
             }
         }
-        function getDiagnosticsProducingTypeChecker() {
-            return diagnosticsProducingTypeChecker || (diagnosticsProducingTypeChecker = ts.createTypeChecker(program, /*produceDiagnostics:*/ true));
-        }
-        function dropDiagnosticsProducingTypeChecker() {
-            diagnosticsProducingTypeChecker = undefined;
-        }
         function getTypeChecker() {
-            return noDiagnosticsTypeChecker || (noDiagnosticsTypeChecker = ts.createTypeChecker(program, /*produceDiagnostics:*/ 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 */, "emit", { path: sourceFile === null || sourceFile === void 0 ? void 0 : sourceFile.path }, /*separateBeginAndEnd*/ true);
@@ -116647,7 +116708,7 @@ var ts;
             // This is because in the -out scenario all files need to be emitted, and therefore all
             // files need to be type checked. And the way to specify that all files need to be type
             // checked is to not pass the file to getEmitResolver.
-            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, 
             /*onlyBuildInfo*/ false, forceDtsEmit);
@@ -116727,15 +116788,7 @@ var ts;
                 if (e instanceof ts.OperationCanceledException) {
                     // We were canceled while performing the operation.  Because our type checker
                     // might be a bad state, we need to throw it away.
-                    //
-                    // Note: we are overly aggressive here.  We do not actually *have* to throw away
-                    // the "noDiagnosticsTypeChecker".  However, for simplicity, i'd like to keep
-                    // the lifetimes of these two TypeCheckers the same.  Also, we generally only
-                    // cancel when the user has made a change anyways.  And, in that case, we (the
-                    // program instance) will get thrown away anyways.  So trying to keep one of
-                    // these type checkers alive doesn't serve much purpose.
-                    noDiagnosticsTypeChecker = undefined;
-                    diagnosticsProducingTypeChecker = undefined;
+                    typeChecker = undefined;
                 }
                 throw e;
             }
@@ -116751,7 +116804,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 /* JS */ || sourceFile.scriptKind === 2 /* JSX */;
                 var isCheckJs = isJs && ts.isCheckJsEnabledForFile(sourceFile, options);
@@ -116803,7 +116856,7 @@ var ts;
         }
         function getSuggestionDiagnostics(sourceFile, cancellationToken) {
             return runWithCancellationToken(function () {
-                return getDiagnosticsProducingTypeChecker().getSuggestionDiagnostics(sourceFile, cancellationToken);
+                return getTypeChecker().getSuggestionDiagnostics(sourceFile, cancellationToken);
             });
         }
         /**
@@ -117023,7 +117076,7 @@ var ts;
         }
         function getDeclarationDiagnosticsForFileNoCache(sourceFile, cancellationToken) {
             return runWithCancellationToken(function () {
-                var resolver = getDiagnosticsProducingTypeChecker().getEmitResolver(sourceFile, cancellationToken);
+                var resolver = getTypeChecker().getEmitResolver(sourceFile, cancellationToken);
                 // Don't actually write any files since we're just getting diagnostics.
                 return ts.getDeclarationDiagnostics(getEmitHost(ts.noop), resolver, sourceFile) || ts.emptyArray;
             });
@@ -117061,7 +117114,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;
@@ -134183,9 +134236,14 @@ var ts;
             if (type) {
                 return type;
             }
-            if (ts.isBinaryExpression(node.parent) && node.parent.operatorToken.kind === 63 /* EqualsToken */ && node === node.parent.left) {
+            var parent = ts.walkUpParenthesizedExpressions(node.parent);
+            if (ts.isBinaryExpression(parent) && parent.operatorToken.kind === 63 /* EqualsToken */ && node === parent.left) {
                 // Object literal is assignment pattern: ({ | } = x)
-                return typeChecker.getTypeAtLocation(node.parent);
+                return typeChecker.getTypeAtLocation(parent);
+            }
+            if (ts.isExpression(parent)) {
+                // f(() => (({ | })));
+                return typeChecker.getContextualType(parent);
             }
             return undefined;
         }
@@ -134978,8 +135036,24 @@ var ts;
         };
     }
     ts.createDocumentRegistryInternal = createDocumentRegistryInternal;
+    function compilerOptionValueToString(value) {
+        var _a;
+        if (value === null || typeof value !== "object") { // eslint-disable-line no-null/no-null
+            return "" + value;
+        }
+        if (ts.isArray(value)) {
+            return "[" + ((_a = ts.map(value, function (e) { return compilerOptionValueToString(e); })) === null || _a === void 0 ? void 0 : _a.join(",")) + "]";
+        }
+        var str = "{";
+        for (var key in value) {
+            if (ts.hasOwnProperty.call(value, key)) { // eslint-disable-line @typescript-eslint/no-unnecessary-qualifier
+                str += key + ": " + compilerOptionValueToString(value[key]);
+            }
+        }
+        return str + "}";
+    }
     function getKeyForCompilationSettings(settings) {
-        return ts.sourceFileAffectingCompilerOptions.map(function (option) { return ts.getCompilerOptionValue(settings, option); }).join("|");
+        return ts.sourceFileAffectingCompilerOptions.map(function (option) { return compilerOptionValueToString(ts.getCompilerOptionValue(settings, option)); }).join("|") + (settings.pathsBasePath ? "|" + settings.pathsBasePath : undefined);
     }
 })(ts || (ts = {}));
 /* Code for finding imports of an exported symbol. Used only by FindAllReferences. */
@@ -146764,7 +146838,28 @@ var ts;
                 // indentation is first non-whitespace character in a previous line
                 // for block indentation, we should look for a line which contains something that's not
                 // whitespace.
-                if (options.indentStyle === ts.IndentStyle.Block) {
+                var currentToken = ts.getTokenAtPosition(sourceFile, position);
+                // for object literal, we want to the indentation work like block
+                // if { starts in any position (can be in the middle of line)
+                // the following indentation should treat { as starting of that line (including leading whitespace)
+                // ```
+                //     const a: { x: undefined, y: undefined } = {}       // leading 4 whitespaces and { starts in the middle of line
+                // ->
+                //     const a: { x: undefined, y: undefined } = {
+                //         x: undefined,
+                //         y: undefined,
+                //     }
+                // ---------------------
+                //     const a: {x : undefined, y: undefined } =
+                //      {}
+                // ->
+                //     const a: { x: undefined, y: undefined } =
+                //      {                                                  // leading 5 whitespaces and { starts at 6 column
+                //          x: undefined,
+                //          y: undefined,
+                //      }
+                // ```
+                if (options.indentStyle === ts.IndentStyle.Block || currentToken.kind === 18 /* OpenBraceToken */) {
                     return getBlockIndent(sourceFile, position, options);
                 }
                 if (precedingToken.kind === 27 /* CommaToken */ && precedingToken.parent.kind !== 221 /* BinaryExpression */) {
@@ -147707,7 +147802,7 @@ var ts;
                 }
                 var startPosition = ts.getPrecedingNonSpaceCharacterPosition(sourceFile.text, fnStart - 1);
                 var indent = sourceFile.text.slice(startPosition, fnStart);
-                this.insertNodeAt(sourceFile, fnStart, tag, { preserveLeadingWhitespace: false, suffix: this.newLineCharacter + indent });
+                this.insertNodeAt(sourceFile, fnStart, tag, { suffix: this.newLineCharacter + indent });
             };
             ChangeTracker.prototype.createJSDocText = function (sourceFile, node) {
                 var comments = ts.flatMap(node.jsDoc, function (jsDoc) {
@@ -148238,7 +148333,7 @@ var ts;
                     ? change.nodes.map(function (n) { return ts.removeSuffix(format(n), newLineCharacter); }).join(((_a = change.options) === null || _a === void 0 ? void 0 : _a.joiner) || newLineCharacter)
                     : format(change.node);
                 // strip initial indentation (spaces or tabs) if text will be inserted in the middle of the line
-                var noIndent = (options.preserveLeadingWhitespace || options.indentation !== undefined || ts.getLineStartPositionForPosition(pos, sourceFile) === pos) ? text : text.replace(/^\s+/, "");
+                var noIndent = (options.indentation !== undefined || ts.getLineStartPositionForPosition(pos, sourceFile) === pos) ? text : text.replace(/^\s+/, "");
                 return (options.prefix || "") + noIndent
                     + ((!options.suffix || ts.endsWith(noIndent, options.suffix))
                         ? "" : options.suffix);
@@ -148931,7 +149026,7 @@ var ts;
             errorCodes: errorCodes,
             getCodeActions: function getCodeActionsToAddMissingAsync(context) {
                 var sourceFile = context.sourceFile, errorCode = context.errorCode, cancellationToken = context.cancellationToken, program = context.program, span = context.span;
-                var diagnostic = ts.find(program.getDiagnosticsProducingTypeChecker().getDiagnostics(sourceFile, cancellationToken), getIsMatchingAsyncError(span, errorCode));
+                var diagnostic = ts.find(program.getTypeChecker().getDiagnostics(sourceFile, cancellationToken), getIsMatchingAsyncError(span, errorCode));
                 var directSpan = diagnostic && diagnostic.relatedInformation && ts.find(diagnostic.relatedInformation, function (r) { return r.code === ts.Diagnostics.Did_you_mean_to_mark_this_function_as_async.code; });
                 var decl = getFixableErrorSpanDeclaration(sourceFile, directSpan);
                 if (!decl) {
@@ -149085,7 +149180,7 @@ var ts;
             return codefix.createCodeFixAction(fixId, changes, ts.Diagnostics.Add_await, fixId, ts.Diagnostics.Fix_all_expressions_possibly_missing_await);
         }
         function isMissingAwaitError(sourceFile, errorCode, span, cancellationToken, program) {
-            var checker = program.getDiagnosticsProducingTypeChecker();
+            var checker = program.getTypeChecker();
             var diagnostics = checker.getDiagnostics(sourceFile, cancellationToken);
             return ts.some(diagnostics, function (_a) {
                 var start = _a.start, length = _a.length, relatedInformation = _a.relatedInformation, code = _a.code;
@@ -149752,20 +149847,6 @@ var ts;
             }
             function createClassElementsFromSymbol(symbol) {
                 var memberElements = [];
-                // all instance members are stored in the "member" array of symbol
-                if (symbol.members) {
-                    symbol.members.forEach(function (member, key) {
-                        if (key === "constructor" && member.valueDeclaration) {
-                            // fn.prototype.constructor = fn
-                            changes.delete(sourceFile, member.valueDeclaration.parent);
-                            return;
-                        }
-                        var memberElement = createClassElement(member, /*modifiers*/ undefined);
-                        if (memberElement) {
-                            memberElements.push.apply(memberElements, memberElement);
-                        }
-                    });
-                }
                 // all static members are stored in the "exports" array of symbol
                 if (symbol.exports) {
                     symbol.exports.forEach(function (member) {
@@ -149778,18 +149859,31 @@ var ts;
                                 firstDeclaration.parent.operatorToken.kind === 63 /* EqualsToken */ &&
                                 ts.isObjectLiteralExpression(firstDeclaration.parent.right)) {
                                 var prototypes = firstDeclaration.parent.right;
-                                var memberElement = createClassElement(prototypes.symbol, /** modifiers */ undefined);
-                                if (memberElement) {
-                                    memberElements.push.apply(memberElements, memberElement);
-                                }
+                                createClassElement(prototypes.symbol, /** modifiers */ undefined, memberElements);
                             }
                         }
                         else {
-                            var memberElement = createClassElement(member, [ts.factory.createToken(124 /* StaticKeyword */)]);
-                            if (memberElement) {
-                                memberElements.push.apply(memberElements, memberElement);
+                            createClassElement(member, [ts.factory.createToken(124 /* StaticKeyword */)], memberElements);
+                        }
+                    });
+                }
+                // all instance members are stored in the "member" array of symbol (done last so instance members pulled from prototype assignments have priority)
+                if (symbol.members) {
+                    symbol.members.forEach(function (member, key) {
+                        var _a, _b, _c, _d;
+                        if (key === "constructor" && member.valueDeclaration) {
+                            var prototypeAssignment = (_d = (_c = (_b = (_a = symbol.exports) === null || _a === void 0 ? void 0 : _a.get("prototype")) === null || _b === void 0 ? void 0 : _b.declarations) === null || _c === void 0 ? void 0 : _c[0]) === null || _d === void 0 ? void 0 : _d.parent;
+                            if (prototypeAssignment && ts.isBinaryExpression(prototypeAssignment) && ts.isObjectLiteralExpression(prototypeAssignment.right) && ts.some(prototypeAssignment.right.properties, isConstructorAssignment)) {
+                                // fn.prototype = { constructor: fn }
+                                // Already deleted in `createClassElement` in first pass
+                            }
+                            else {
+                                // fn.prototype.constructor = fn
+                                changes.delete(sourceFile, member.valueDeclaration.parent);
                             }
+                            return;
                         }
+                        createClassElement(member, /*modifiers*/ undefined, memberElements);
                     });
                 }
                 return memberElements;
@@ -149817,18 +149911,26 @@ var ts;
                         });
                     }
                 }
-                function createClassElement(symbol, modifiers) {
+                function createClassElement(symbol, modifiers, members) {
                     // Right now the only thing we can convert are function expressions, which are marked as methods
                     // or { x: y } type prototype assignments, which are marked as ObjectLiteral
-                    var members = [];
                     if (!(symbol.flags & 8192 /* Method */) && !(symbol.flags & 4096 /* ObjectLiteral */)) {
-                        return members;
+                        return;
                     }
                     var memberDeclaration = symbol.valueDeclaration;
                     var assignmentBinaryExpression = memberDeclaration.parent;
                     var assignmentExpr = assignmentBinaryExpression.right;
                     if (!shouldConvertDeclaration(memberDeclaration, assignmentExpr)) {
-                        return members;
+                        return;
+                    }
+                    if (ts.some(members, function (m) {
+                        var name = ts.getNameOfDeclaration(m);
+                        if (name && ts.isIdentifier(name) && ts.idText(name) === ts.symbolName(symbol)) {
+                            return true; // class member already made for this name
+                        }
+                        return false;
+                    })) {
+                        return;
                     }
                     // delete the entire statement if this expression is the sole expression to take care of the semicolon at the end
                     var nodeToDelete = assignmentBinaryExpression.parent && assignmentBinaryExpression.parent.kind === 238 /* ExpressionStatement */
@@ -149837,43 +149939,44 @@ var ts;
                     if (!assignmentExpr) {
                         members.push(ts.factory.createPropertyDeclaration([], modifiers, symbol.name, /*questionToken*/ undefined, 
                         /*type*/ undefined, /*initializer*/ undefined));
-                        return members;
+                        return;
                     }
                     // f.x = expr
                     if (ts.isAccessExpression(memberDeclaration) && (ts.isFunctionExpression(assignmentExpr) || ts.isArrowFunction(assignmentExpr))) {
                         var quotePreference = ts.getQuotePreference(sourceFile, preferences);
                         var name = tryGetPropertyName(memberDeclaration, compilerOptions, quotePreference);
                         if (name) {
-                            return createFunctionLikeExpressionMember(members, assignmentExpr, name);
+                            createFunctionLikeExpressionMember(members, assignmentExpr, name);
                         }
-                        return members;
+                        return;
                     }
                     // f.prototype = { ... }
                     else if (ts.isObjectLiteralExpression(assignmentExpr)) {
-                        return ts.flatMap(assignmentExpr.properties, function (property) {
+                        ts.forEach(assignmentExpr.properties, function (property) {
                             if (ts.isMethodDeclaration(property) || ts.isGetOrSetAccessorDeclaration(property)) {
                                 // MethodDeclaration and AccessorDeclaration can appear in a class directly
-                                return members.concat(property);
+                                members.push(property);
                             }
                             if (ts.isPropertyAssignment(property) && ts.isFunctionExpression(property.initializer)) {
-                                return createFunctionLikeExpressionMember(members, property.initializer, property.name);
+                                createFunctionLikeExpressionMember(members, property.initializer, property.name);
                             }
                             // Drop constructor assignments
                             if (isConstructorAssignment(property))
-                                return members;
-                            return [];
+                                return;
+                            return;
                         });
+                        return;
                     }
                     else {
                         // Don't try to declare members in JavaScript files
                         if (ts.isSourceFileJS(sourceFile))
-                            return members;
+                            return;
                         if (!ts.isPropertyAccessExpression(memberDeclaration))
-                            return members;
+                            return;
                         var prop = ts.factory.createPropertyDeclaration(/*decorators*/ undefined, modifiers, memberDeclaration.name, /*questionToken*/ undefined, /*type*/ undefined, assignmentExpr);
                         ts.copyLeadingComments(assignmentBinaryExpression.parent, prop, sourceFile);
                         members.push(prop);
-                        return members;
+                        return;
                     }
                     function createFunctionLikeExpressionMember(members, expression, name) {
                         if (ts.isFunctionExpression(expression))
@@ -149886,7 +149989,8 @@ var ts;
                         var method = ts.factory.createMethodDeclaration(/*decorators*/ undefined, fullModifiers, /*asteriskToken*/ undefined, name, /*questionToken*/ undefined, 
                         /*typeParameters*/ undefined, functionExpression.parameters, /*type*/ undefined, functionExpression.body);
                         ts.copyLeadingComments(assignmentBinaryExpression, method, sourceFile);
-                        return members.concat(method);
+                        members.push(method);
+                        return;
                     }
                     function createArrowFunctionExpressionMember(members, arrowFunction, name) {
                         var arrowFunctionBody = arrowFunction.body;
@@ -149903,7 +150007,7 @@ var ts;
                         var method = ts.factory.createMethodDeclaration(/*decorators*/ undefined, fullModifiers, /*asteriskToken*/ undefined, name, /*questionToken*/ undefined, 
                         /*typeParameters*/ undefined, arrowFunction.parameters, /*type*/ undefined, bodyBlock);
                         ts.copyLeadingComments(assignmentBinaryExpression, method, sourceFile);
-                        return members.concat(method);
+                        members.push(method);
                     }
                 }
             }
@@ -153337,7 +153441,7 @@ var ts;
                 var properties = ts.arrayFrom(checker.getUnmatchedProperties(checker.getTypeAtLocation(parent), checker.getTypeAtLocation(param), /* requireOptionalProperties */ false, /* matchDiscriminantProperties */ false));
                 if (!ts.length(properties))
                     return undefined;
-                return { kind: 3 /* ObjectLiteral */, token: param.name, properties: properties, indentation: 0, parentDeclaration: parent };
+                return { kind: 3 /* ObjectLiteral */, token: param.name, properties: properties, parentDeclaration: parent };
             }
             if (!ts.isMemberName(token))
                 return undefined;
@@ -153345,7 +153449,7 @@ var ts;
                 var properties = ts.arrayFrom(checker.getUnmatchedProperties(checker.getTypeAtLocation(parent.initializer), checker.getTypeAtLocation(token), /* requireOptionalProperties */ false, /* matchDiscriminantProperties */ false));
                 if (!ts.length(properties))
                     return undefined;
-                return { kind: 3 /* ObjectLiteral */, token: token, properties: properties, indentation: undefined, parentDeclaration: parent.initializer };
+                return { kind: 3 /* ObjectLiteral */, token: token, properties: properties, parentDeclaration: parent.initializer };
             }
             if (ts.isIdentifier(token) && ts.isJsxOpeningLikeElement(token.parent)) {
                 var target = ts.getEmitScriptTarget(program.getCompilerOptions());