typescript 4.6.0-dev.20220113 → 4.6.0-dev.20220114

package/lib/tsserver.js

@@ -100,7 +100,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.20220113";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220114";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -8288,7 +8288,7 @@ var ts;
         Parameter_0_cannot_reference_identifier_1_declared_after_it: diag(2373, ts.DiagnosticCategory.Error, "Parameter_0_cannot_reference_identifier_1_declared_after_it_2373", "Parameter '{0}' cannot reference identifier '{1}' declared after it."),
         Duplicate_index_signature_for_type_0: diag(2374, ts.DiagnosticCategory.Error, "Duplicate_index_signature_for_type_0_2374", "Duplicate index signature for type '{0}'."),
         Type_0_is_not_assignable_to_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefined_to_the_types_of_the_target_s_properties: diag(2375, ts.DiagnosticCategory.Error, "Type_0_is_not_assignable_to_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefi_2375", "Type '{0}' is not assignable to type '{1}' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties."),
-        A_super_call_must_be_the_first_statement_in_the_constructor_when_a_class_contains_initialized_properties_parameter_properties_or_private_identifiers: diag(2376, ts.DiagnosticCategory.Error, "A_super_call_must_be_the_first_statement_in_the_constructor_when_a_class_contains_initialized_proper_2376", "A 'super' call must be the first statement in the constructor when a class contains initialized properties, parameter properties, or private identifiers."),
+        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: diag(2376, ts.DiagnosticCategory.Error, "A_super_call_must_be_the_first_statement_in_the_constructor_to_refer_to_super_or_this_when_a_derived_2376", "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."),
         Constructors_for_derived_classes_must_contain_a_super_call: diag(2377, ts.DiagnosticCategory.Error, "Constructors_for_derived_classes_must_contain_a_super_call_2377", "Constructors for derived classes must contain a 'super' call."),
         A_get_accessor_must_return_a_value: diag(2378, ts.DiagnosticCategory.Error, "A_get_accessor_must_return_a_value_2378", "A 'get' accessor must return a value."),
         Argument_of_type_0_is_not_assignable_to_parameter_of_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefined_to_the_types_of_the_target_s_properties: diag(2379, ts.DiagnosticCategory.Error, "Argument_of_type_0_is_not_assignable_to_parameter_of_type_1_with_exactOptionalPropertyTypes_Colon_tr_2379", "Argument of type '{0}' is not assignable to parameter of type '{1}' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties."),
@@ -8311,6 +8311,7 @@ var ts;
         constructor_cannot_be_used_as_a_parameter_property_name: diag(2398, ts.DiagnosticCategory.Error, "constructor_cannot_be_used_as_a_parameter_property_name_2398", "'constructor' cannot be used as a parameter property name."),
         Duplicate_identifier_this_Compiler_uses_variable_declaration_this_to_capture_this_reference: diag(2399, ts.DiagnosticCategory.Error, "Duplicate_identifier_this_Compiler_uses_variable_declaration_this_to_capture_this_reference_2399", "Duplicate identifier '_this'. Compiler uses variable declaration '_this' to capture 'this' reference."),
         Expression_resolves_to_variable_declaration_this_that_compiler_uses_to_capture_this_reference: diag(2400, ts.DiagnosticCategory.Error, "Expression_resolves_to_variable_declaration_this_that_compiler_uses_to_capture_this_reference_2400", "Expression resolves to variable declaration '_this' that compiler uses to capture 'this' reference."),
+        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: diag(2401, ts.DiagnosticCategory.Error, "A_super_call_must_be_a_root_level_statement_within_a_constructor_of_a_derived_class_that_contains_in_2401", "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."),
         Expression_resolves_to_super_that_compiler_uses_to_capture_base_class_reference: diag(2402, ts.DiagnosticCategory.Error, "Expression_resolves_to_super_that_compiler_uses_to_capture_base_class_reference_2402", "Expression resolves to '_super' that compiler uses to capture base class reference."),
         Subsequent_variable_declarations_must_have_the_same_type_Variable_0_must_be_of_type_1_but_here_has_type_2: diag(2403, ts.DiagnosticCategory.Error, "Subsequent_variable_declarations_must_have_the_same_type_Variable_0_must_be_of_type_1_but_here_has_t_2403", "Subsequent variable declarations must have the same type.  Variable '{0}' must be of type '{1}', but here has type '{2}'."),
         The_left_hand_side_of_a_for_in_statement_cannot_use_a_type_annotation: diag(2404, ts.DiagnosticCategory.Error, "The_left_hand_side_of_a_for_in_statement_cannot_use_a_type_annotation_2404", "The left-hand side of a 'for...in' statement cannot use a type annotation."),
@@ -15471,6 +15472,34 @@ var ts;
         }
     }
     ts.getThisContainer = getThisContainer;
+    /**
+     * @returns Whether the node creates a new 'this' scope for its children.
+     */
+    function isThisContainerOrFunctionBlock(node) {
+        switch (node.kind) {
+            // Arrow functions use the same scope, but may do so in a "delayed" manner
+            // For example, `const getThis = () => this` may be before a super() call in a derived constructor
+            case 213 /* ArrowFunction */:
+            case 255 /* FunctionDeclaration */:
+            case 212 /* FunctionExpression */:
+            case 166 /* PropertyDeclaration */:
+                return true;
+            case 234 /* Block */:
+                switch (node.parent.kind) {
+                    case 170 /* Constructor */:
+                    case 168 /* MethodDeclaration */:
+                    case 171 /* GetAccessor */:
+                    case 172 /* SetAccessor */:
+                        // Object properties can have computed names; only method-like bodies start a new scope
+                        return true;
+                    default:
+                        return false;
+                }
+            default:
+                return false;
+        }
+    }
+    ts.isThisContainerOrFunctionBlock = isThisContainerOrFunctionBlock;
     function isInTopLevelContext(node) {
         // The name of a class or function declaration is a BindingIdentifier in its surrounding scope.
         if (ts.isIdentifier(node) && (ts.isClassDeclaration(node.parent) || ts.isFunctionDeclaration(node.parent)) && node.parent.name === node) {
@@ -26057,7 +26086,7 @@ var ts;
          * @param visitor Optional callback used to visit any custom prologue directives.
          */
         function copyPrologue(source, target, ensureUseStrict, visitor) {
-            var offset = copyStandardPrologue(source, target, ensureUseStrict);
+            var offset = copyStandardPrologue(source, target, 0, ensureUseStrict);
             return copyCustomPrologue(source, target, offset, visitor);
         }
         function isUseStrictPrologue(node) {
@@ -26070,12 +26099,14 @@ var ts;
          * Copies only the standard (string-expression) prologue-directives into the target statement-array.
          * @param source origin statements array
          * @param target result statements array
+         * @param statementOffset The offset at which to begin the copy.
          * @param ensureUseStrict boolean determining whether the function need to add prologue-directives
+         * @returns Count of how many directive statements were copied.
          */
-        function copyStandardPrologue(source, target, ensureUseStrict) {
+        function copyStandardPrologue(source, target, statementOffset, ensureUseStrict) {
+            if (statementOffset === void 0) { statementOffset = 0; }
             ts.Debug.assert(target.length === 0, "Prologue directives should be at the first statement in the target statements array");
             var foundUseStrict = false;
-            var statementOffset = 0;
             var numStatements = source.length;
             while (statementOffset < numStatements) {
                 var statement = source[statementOffset];
@@ -27498,7 +27529,7 @@ var ts;
         importName: "__createBinding",
         scoped: false,
         priority: 1,
-        text: "\n            var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n                if (k2 === undefined) k2 = k;\n                Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });\n            }) : (function(o, m, k, k2) {\n                if (k2 === undefined) k2 = k;\n                o[k2] = m[k];\n            }));"
+        text: "\n            var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n                if (k2 === undefined) k2 = k;\n                var desc = Object.getOwnPropertyDescriptor(m, k);\n                if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n                  desc = { enumerable: true, get: function() { return m[k]; } };\n                }\n                Object.defineProperty(o, k2, desc);\n            }) : (function(o, m, k, k2) {\n                if (k2 === undefined) k2 = k;\n                o[k2] = m[k];\n            }));"
     };
     ts.setModuleDefaultHelper = {
         name: "typescript:commonjscreatevalue",
@@ -41133,7 +41164,7 @@ var ts;
                     ? 1 /* Recursive */ : 0 /* None */
             };
         }
-        if (ts.isImplicitGlob(spec)) {
+        if (ts.isImplicitGlob(spec.substring(spec.lastIndexOf(ts.directorySeparator) + 1))) {
             return {
                 key: useCaseSensitiveFileNames ? spec : ts.toFileNameLowerCase(spec),
                 flags: 1 /* Recursive */
@@ -78518,32 +78549,38 @@ var ts;
                     if (classExtendsNull) {
                         error(superCall, ts.Diagnostics.A_constructor_cannot_contain_a_super_call_when_its_class_extends_null);
                     }
-                    // The first statement in the body of a constructor (excluding prologue directives) must be a super call
-                    // if both of the following are true:
+                    // 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 superCallShouldBeFirst = (ts.getEmitScriptTarget(compilerOptions) !== 99 /* ESNext */ || !useDefineForClassFields) &&
+                    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 */); }));
-                    // Skip past any prologue directives to find the first statement
-                    // to ensure that it was a super call.
-                    if (superCallShouldBeFirst) {
-                        var statements = node.body.statements;
-                        var superCallStatement = void 0;
-                        for (var _i = 0, statements_4 = statements; _i < statements_4.length; _i++) {
-                            var statement = statements_4[_i];
-                            if (statement.kind === 237 /* ExpressionStatement */ && ts.isSuperCall(statement.expression)) {
-                                superCallStatement = statement;
-                                break;
+                    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;
+                                }
                             }
-                            if (!ts.isPrologueDirective(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);
                             }
                         }
-                        if (!superCallStatement) {
-                            error(node, ts.Diagnostics.A_super_call_must_be_the_first_statement_in_the_constructor_when_a_class_contains_initialized_properties_parameter_properties_or_private_identifiers);
-                        }
                     }
                 }
                 else if (!classExtendsNull) {
@@ -78551,6 +78588,19 @@ var ts;
                 }
             }
         }
+        function superCallIsRootLevelInConstructor(superCall, body) {
+            var superCallParent = ts.walkUpParenthesizedExpressions(superCall.parent);
+            return ts.isExpressionStatement(superCallParent) && superCallParent.parent === body;
+        }
+        function nodeImmediatelyReferencesSuperOrThis(node) {
+            if (node.kind === 106 /* SuperKeyword */ || node.kind === 108 /* ThisKeyword */) {
+                return true;
+            }
+            if (ts.isThisContainerOrFunctionBlock(node)) {
+                return false;
+            }
+            return !!ts.forEachChild(node, nodeImmediatelyReferencesSuperOrThis);
+        }
         function checkAccessorDeclaration(node) {
             if (produceDiagnostics) {
                 // Grammar checking accessors
@@ -88673,34 +88723,31 @@ var ts;
     }
     ts.getNonAssignmentOperatorForCompoundAssignment = getNonAssignmentOperatorForCompoundAssignment;
     /**
-     * Adds super call and preceding prologue directives into the list of statements.
-     *
-     * @param ctor The constructor node.
-     * @param result The list of statements.
-     * @param visitor The visitor to apply to each node added to the result array.
-     * @returns index of the statement that follows super call
+     * @returns Contained super() call from descending into the statement ignoring parentheses, if that call exists.
+     */
+    function getSuperCallFromStatement(statement) {
+        if (!ts.isExpressionStatement(statement)) {
+            return undefined;
+        }
+        var expression = ts.skipParentheses(statement.expression);
+        return ts.isSuperCall(expression)
+            ? expression
+            : undefined;
+    }
+    ts.getSuperCallFromStatement = getSuperCallFromStatement;
+    /**
+     * @returns The index (after prologue statements) of a super call, or -1 if not found.
      */
-    function addPrologueDirectivesAndInitialSuperCall(factory, ctor, result, visitor) {
-        if (ctor.body) {
-            var statements = ctor.body.statements;
-            // add prologue directives to the list (if any)
-            var index = factory.copyPrologue(statements, result, /*ensureUseStrict*/ false, visitor);
-            if (index === statements.length) {
-                // list contains nothing but prologue directives (or empty) - exit
-                return index;
-            }
-            var superIndex = ts.findIndex(statements, function (s) { return ts.isExpressionStatement(s) && ts.isSuperCall(s.expression); }, index);
-            if (superIndex > -1) {
-                for (var i = index; i <= superIndex; i++) {
-                    result.push(ts.visitNode(statements[i], visitor, ts.isStatement));
-                }
-                return superIndex + 1;
+    function findSuperStatementIndex(statements, indexAfterLastPrologueStatement) {
+        for (var i = indexAfterLastPrologueStatement; i < statements.length; i += 1) {
+            var statement = statements[i];
+            if (getSuperCallFromStatement(statement)) {
+                return i;
             }
-            return index;
         }
-        return 0;
+        return -1;
     }
-    ts.addPrologueDirectivesAndInitialSuperCall = addPrologueDirectivesAndInitialSuperCall;
+    ts.findSuperStatementIndex = findSuperStatementIndex;
     function getProperties(node, requireInitializer, isStatic) {
         return ts.filter(node.members, function (m) { return isInitializedOrStaticProperty(m, requireInitializer, isStatic); });
     }
@@ -90938,10 +90985,14 @@ var ts;
                 return ts.visitFunctionBody(body, visitor, context);
             }
             var statements = [];
-            var indexOfFirstStatement = 0;
             resumeLexicalEnvironment();
-            indexOfFirstStatement = ts.addPrologueDirectivesAndInitialSuperCall(factory, constructor, statements, visitor);
-            // Add parameters with property assignments. Transforms this:
+            var indexAfterLastPrologueStatement = factory.copyPrologue(body.statements, statements, /*ensureUseStrict*/ false, visitor);
+            var superStatementIndex = ts.findSuperStatementIndex(body.statements, indexAfterLastPrologueStatement);
+            // If there was a super call, visit existing statements up to and including it
+            if (superStatementIndex >= 0) {
+                ts.addRange(statements, ts.visitNodes(body.statements, visitor, ts.isStatement, indexAfterLastPrologueStatement, superStatementIndex + 1 - indexAfterLastPrologueStatement));
+            }
+            // Transform parameters into property assignments. Transforms this:
             //
             //  constructor (public x, public y) {
             //  }
@@ -90953,9 +91004,17 @@ var ts;
             //      this.y = y;
             //  }
             //
-            ts.addRange(statements, ts.map(parametersWithPropertyAssignments, transformParameterWithPropertyAssignment));
-            // Add the existing statements, skipping the initial super call.
-            ts.addRange(statements, ts.visitNodes(body.statements, visitor, ts.isStatement, indexOfFirstStatement));
+            var parameterPropertyAssignments = ts.mapDefined(parametersWithPropertyAssignments, transformParameterWithPropertyAssignment);
+            // If there is a super() call, the parameter properties go immediately after it
+            if (superStatementIndex >= 0) {
+                ts.addRange(statements, parameterPropertyAssignments);
+            }
+            // Since there was no super() call, parameter properties are the first statements in the constructor
+            else {
+                statements = ts.addRange(parameterPropertyAssignments, statements);
+            }
+            // Add remaining statements from the body, skipping the super() call if it was found
+            ts.addRange(statements, ts.visitNodes(body.statements, visitor, ts.isStatement, superStatementIndex + 1));
             // End the lexical environment.
             statements = factory.mergeLexicalEnvironment(statements, endLexicalEnvironment());
             var block = factory.createBlock(ts.setTextRange(factory.createNodeArray(statements), body.statements), /*multiLine*/ true);
@@ -92853,6 +92912,7 @@ var ts;
             /*modifiers*/ undefined, parameters !== null && parameters !== void 0 ? parameters : [], body), constructor || node), constructor));
         }
         function transformConstructorBody(node, constructor, isDerivedClass) {
+            var _a;
             var properties = ts.getProperties(node, /*requireInitializer*/ false, /*isStatic*/ false);
             if (!useDefineForClassFields) {
                 properties = ts.filter(properties, function (property) { return !!property.initializer || ts.isPrivateIdentifier(property.name); });
@@ -92864,9 +92924,21 @@ var ts;
                 return ts.visitFunctionBody(/*node*/ undefined, visitor, context);
             }
             resumeLexicalEnvironment();
-            var indexOfFirstStatement = 0;
+            var needsSyntheticConstructor = !constructor && isDerivedClass;
+            var indexOfFirstStatementAfterSuper = 0;
+            var prologueStatementCount = 0;
+            var superStatementIndex = -1;
             var statements = [];
-            if (!constructor && isDerivedClass) {
+            if ((_a = constructor === null || constructor === void 0 ? void 0 : constructor.body) === null || _a === void 0 ? void 0 : _a.statements) {
+                prologueStatementCount = factory.copyPrologue(constructor.body.statements, statements, /*ensureUseStrict*/ false, visitor);
+                superStatementIndex = ts.findSuperStatementIndex(constructor.body.statements, prologueStatementCount);
+                // If there was a super call, visit existing statements up to and including it
+                if (superStatementIndex >= 0) {
+                    indexOfFirstStatementAfterSuper = superStatementIndex + 1;
+                    statements = __spreadArray(__spreadArray(__spreadArray([], statements.slice(0, prologueStatementCount), true), ts.visitNodes(constructor.body.statements, visitor, ts.isStatement, prologueStatementCount, indexOfFirstStatementAfterSuper - prologueStatementCount), true), statements.slice(prologueStatementCount), true);
+                }
+            }
+            if (needsSyntheticConstructor) {
                 // Add a synthetic `super` call:
                 //
                 //  super(...arguments);
@@ -92874,9 +92946,6 @@ var ts;
                 statements.push(factory.createExpressionStatement(factory.createCallExpression(factory.createSuper(), 
                 /*typeArguments*/ undefined, [factory.createSpreadElement(factory.createIdentifier("arguments"))])));
             }
-            if (constructor) {
-                indexOfFirstStatement = ts.addPrologueDirectivesAndInitialSuperCall(factory, constructor, statements, visitor);
-            }
             // Add the property initializers. Transforms this:
             //
             //  public x = 1;
@@ -92887,31 +92956,59 @@ var ts;
             //      this.x = 1;
             //  }
             //
+            // If we do useDefineForClassFields, they'll be converted elsewhere.
+            // We instead *remove* them from the transformed output at this stage.
+            var parameterPropertyDeclarationCount = 0;
             if (constructor === null || constructor === void 0 ? void 0 : constructor.body) {
-                var afterParameterProperties = ts.findIndex(constructor.body.statements, function (s) { return !ts.isParameterPropertyDeclaration(ts.getOriginalNode(s), constructor); }, indexOfFirstStatement);
-                if (afterParameterProperties === -1) {
-                    afterParameterProperties = constructor.body.statements.length;
+                if (useDefineForClassFields) {
+                    statements = statements.filter(function (statement) { return !ts.isParameterPropertyDeclaration(ts.getOriginalNode(statement), constructor); });
                 }
-                if (afterParameterProperties > indexOfFirstStatement) {
-                    if (!useDefineForClassFields) {
-                        ts.addRange(statements, ts.visitNodes(constructor.body.statements, visitor, ts.isStatement, indexOfFirstStatement, afterParameterProperties - indexOfFirstStatement));
+                else {
+                    for (var _i = 0, _b = constructor.body.statements; _i < _b.length; _i++) {
+                        var statement = _b[_i];
+                        if (ts.isParameterPropertyDeclaration(ts.getOriginalNode(statement), constructor)) {
+                            parameterPropertyDeclarationCount++;
+                        }
+                    }
+                    if (parameterPropertyDeclarationCount > 0) {
+                        var parameterProperties = ts.visitNodes(constructor.body.statements, visitor, ts.isStatement, indexOfFirstStatementAfterSuper, parameterPropertyDeclarationCount);
+                        // If there was a super() call found, add parameter properties immediately after it
+                        if (superStatementIndex >= 0) {
+                            ts.addRange(statements, parameterProperties);
+                        }
+                        // If a synthetic super() call was added, add them just after it
+                        else if (needsSyntheticConstructor) {
+                            statements = __spreadArray(__spreadArray([
+                                statements[0]
+                            ], parameterProperties, true), statements.slice(1), true);
+                        }
+                        // Since there wasn't a super() call, add them to the top of the constructor
+                        else {
+                            statements = __spreadArray(__spreadArray([], parameterProperties, true), statements, true);
+                        }
+                        indexOfFirstStatementAfterSuper += parameterPropertyDeclarationCount;
                     }
-                    indexOfFirstStatement = afterParameterProperties;
                 }
             }
             var receiver = factory.createThis();
             // private methods can be called in property initializers, they should execute first.
             addMethodStatements(statements, privateMethodsAndAccessors, receiver);
             addPropertyOrClassStaticBlockStatements(statements, properties, receiver);
-            // Add existing statements, skipping the initial super call.
+            // Add existing statements after the initial prologues and super call
             if (constructor) {
-                ts.addRange(statements, ts.visitNodes(constructor.body.statements, visitor, ts.isStatement, indexOfFirstStatement));
+                ts.addRange(statements, ts.visitNodes(constructor.body.statements, visitBodyStatement, ts.isStatement, indexOfFirstStatementAfterSuper + prologueStatementCount));
             }
             statements = factory.mergeLexicalEnvironment(statements, endLexicalEnvironment());
             return ts.setTextRange(factory.createBlock(ts.setTextRange(factory.createNodeArray(statements), 
             /*location*/ constructor ? constructor.body.statements : node.members), 
             /*multiLine*/ true), 
             /*location*/ constructor ? constructor.body : undefined);
+            function visitBodyStatement(statement) {
+                if (useDefineForClassFields && ts.isParameterPropertyDeclaration(ts.getOriginalNode(statement), constructor)) {
+                    return undefined;
+                }
+                return visitor(statement);
+            }
         }
         /**
          * Generates assignment statements for property initializers.
@@ -96703,37 +96800,39 @@ var ts;
             var prologue = [];
             var statements = [];
             resumeLexicalEnvironment();
+            // In derived classes, there may be code before the necessary super() call
+            // We'll remove pre-super statements to be tacked on after the rest of the body
+            var existingPrologue = ts.takeWhile(constructor.body.statements, ts.isPrologueDirective);
+            var _a = findSuperCallAndStatementIndex(constructor.body.statements, existingPrologue), superCall = _a.superCall, superStatementIndex = _a.superStatementIndex;
+            var postSuperStatementsStart = superStatementIndex === -1 ? existingPrologue.length : superStatementIndex + 1;
             // If a super call has already been synthesized,
             // we're going to assume that we should just transform everything after that.
             // The assumption is that no prior step in the pipeline has added any prologue directives.
-            var statementOffset = 0;
+            var statementOffset = postSuperStatementsStart;
             if (!hasSynthesizedSuper)
-                statementOffset = factory.copyStandardPrologue(constructor.body.statements, prologue, /*ensureUseStrict*/ false);
-            addDefaultValueAssignmentsIfNeeded(statements, constructor);
-            addRestParameterIfNeeded(statements, constructor, hasSynthesizedSuper);
+                statementOffset = factory.copyStandardPrologue(constructor.body.statements, prologue, statementOffset, /*ensureUseStrict*/ false);
             if (!hasSynthesizedSuper)
-                statementOffset = factory.copyCustomPrologue(constructor.body.statements, statements, statementOffset, visitor);
-            // If the first statement is a call to `super()`, visit the statement directly
+                statementOffset = factory.copyCustomPrologue(constructor.body.statements, statements, statementOffset, visitor, /*filter*/ undefined);
+            // If there already exists a call to `super()`, visit the statement directly
             var superCallExpression;
             if (hasSynthesizedSuper) {
                 superCallExpression = createDefaultSuperCallOrThis();
             }
-            else if (isDerivedClass && statementOffset < constructor.body.statements.length) {
-                var firstStatement = constructor.body.statements[statementOffset];
-                if (ts.isExpressionStatement(firstStatement) && ts.isSuperCall(firstStatement.expression)) {
-                    superCallExpression = visitImmediateSuperCallInBody(firstStatement.expression);
-                }
+            else if (superCall) {
+                superCallExpression = visitSuperCallInBody(superCall);
             }
             if (superCallExpression) {
                 hierarchyFacts |= 8192 /* ConstructorWithCapturedSuper */;
-                statementOffset++; // skip this statement, we will add it after visiting the rest of the body.
             }
+            // Add parameter defaults at the beginning of the output, with prologue statements
+            addDefaultValueAssignmentsIfNeeded(prologue, constructor);
+            addRestParameterIfNeeded(prologue, constructor, hasSynthesizedSuper);
             // visit the remaining statements
             ts.addRange(statements, ts.visitNodes(constructor.body.statements, visitor, ts.isStatement, /*start*/ statementOffset));
             factory.mergeLexicalEnvironment(prologue, endLexicalEnvironment());
             insertCaptureNewTargetIfNeeded(prologue, constructor, /*copyOnWrite*/ false);
-            if (isDerivedClass) {
-                if (superCallExpression && statementOffset === constructor.body.statements.length && !(constructor.body.transformFlags & 8192 /* ContainsLexicalThis */)) {
+            if (isDerivedClass || superCallExpression) {
+                if (superCallExpression && postSuperStatementsStart === constructor.body.statements.length && !(constructor.body.transformFlags & 8192 /* ContainsLexicalThis */)) {
                     // If the subclass constructor does *not* contain `this` and *ends* with a `super()` call, we will use the
                     // following representation:
                     //
@@ -96753,10 +96852,10 @@ var ts;
                     //     return C;
                     // })(Base);
                     // ```
-                    var superCall = ts.cast(ts.cast(superCallExpression, ts.isBinaryExpression).left, ts.isCallExpression);
+                    var superCall_1 = ts.cast(ts.cast(superCallExpression, ts.isBinaryExpression).left, ts.isCallExpression);
                     var returnStatement = factory.createReturnStatement(superCallExpression);
-                    ts.setCommentRange(returnStatement, ts.getCommentRange(superCall));
-                    ts.setEmitFlags(superCall, 1536 /* NoComments */);
+                    ts.setCommentRange(returnStatement, ts.getCommentRange(superCall_1));
+                    ts.setEmitFlags(superCall_1, 1536 /* NoComments */);
                     statements.push(returnStatement);
                 }
                 else {
@@ -96781,9 +96880,19 @@ var ts;
                     //     return C;
                     // })(Base);
                     // ```
-                    // Since the `super()` call was the first statement, we insert the `this` capturing call to
-                    // `super()` at the top of the list of `statements` (after any pre-existing custom prologues).
-                    insertCaptureThisForNode(statements, constructor, superCallExpression || createActualThis());
+                    // If the super() call is the first statement, we can directly create and assign its result to `_this`
+                    if (superStatementIndex <= existingPrologue.length) {
+                        insertCaptureThisForNode(statements, constructor, superCallExpression || createActualThis());
+                    }
+                    // Since the `super()` call isn't the first statement, it's split across 1-2 statements:
+                    // * A prologue `var _this = this;`, in case the constructor accesses this before super()
+                    // * If it exists, a reassignment to that `_this` of the super() call
+                    else {
+                        insertCaptureThisForNode(prologue, constructor, createActualThis());
+                        if (superCallExpression) {
+                            insertSuperThisCaptureThisForNode(statements, superCallExpression);
+                        }
+                    }
                     if (!isSufficientlyCoveredByReturnStatements(constructor.body)) {
                         statements.push(factory.createReturnStatement(factory.createUniqueName("_this", 16 /* Optimistic */ | 32 /* FileLevel */)));
                     }
@@ -96806,11 +96915,27 @@ var ts;
                 // ```
                 insertCaptureThisForNodeIfNeeded(prologue, constructor);
             }
-            var block = factory.createBlock(ts.setTextRange(factory.createNodeArray(ts.concatenate(prologue, statements)), 
+            var body = factory.createBlock(ts.setTextRange(factory.createNodeArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray([], existingPrologue, true), prologue, true), (superStatementIndex <= existingPrologue.length ? ts.emptyArray : ts.visitNodes(constructor.body.statements, visitor, ts.isStatement, existingPrologue.length, superStatementIndex)), true), statements, true)), 
             /*location*/ constructor.body.statements), 
             /*multiLine*/ true);
-            ts.setTextRange(block, constructor.body);
-            return block;
+            ts.setTextRange(body, constructor.body);
+            return body;
+        }
+        function findSuperCallAndStatementIndex(originalBodyStatements, existingPrologue) {
+            for (var i = existingPrologue.length; i < originalBodyStatements.length; i += 1) {
+                var superCall = ts.getSuperCallFromStatement(originalBodyStatements[i]);
+                if (superCall) {
+                    // With a super() call, split the statements into pre-super() and 'body' (post-super())
+                    return {
+                        superCall: superCall,
+                        superStatementIndex: i,
+                    };
+                }
+            }
+            // Since there was no super() call found, consider all statements to be in the main 'body' (post-super())
+            return {
+                superStatementIndex: -1,
+            };
         }
         /**
          * We want to try to avoid emitting a return statement in certain cases if a user already returned something.
@@ -97039,6 +97164,18 @@ var ts;
             }
             return false;
         }
+        /**
+         * Assigns the `this` in a constructor to the result of its `super()` call.
+         *
+         * @param statements Statements in the constructor body.
+         * @param superExpression Existing `super()` call for the constructor.
+         */
+        function insertSuperThisCaptureThisForNode(statements, superExpression) {
+            enableSubstitutionsForCapturedThis();
+            var assignSuperExpression = factory.createExpressionStatement(factory.createBinaryExpression(factory.createThis(), 63 /* EqualsToken */, superExpression));
+            ts.insertStatementAfterCustomPrologue(statements, assignSuperExpression);
+            ts.setCommentRange(assignSuperExpression, ts.getOriginalNode(superExpression).parent);
+        }
         function insertCaptureThisForNode(statements, node, initializer) {
             enableSubstitutionsForCapturedThis();
             var captureThisStatement = factory.createVariableStatement(
@@ -97348,7 +97485,7 @@ var ts;
             if (ts.isBlock(body)) {
                 // ensureUseStrict is false because no new prologue-directive should be added.
                 // addStandardPrologue will put already-existing directives at the beginning of the target statement-array
-                statementOffset = factory.copyStandardPrologue(body.statements, prologue, /*ensureUseStrict*/ false);
+                statementOffset = factory.copyStandardPrologue(body.statements, prologue, 0, /*ensureUseStrict*/ false);
                 statementOffset = factory.copyCustomPrologue(body.statements, statements, statementOffset, visitor, ts.isHoistedFunction);
                 statementOffset = factory.copyCustomPrologue(body.statements, statements, statementOffset, visitor, ts.isHoistedVariableStatement);
             }
@@ -98719,7 +98856,7 @@ var ts;
             /*type*/ undefined, factory.updateBlock(func.body, statements))), 
             /*typeArguments*/ undefined, call.arguments))));
         }
-        function visitImmediateSuperCallInBody(node) {
+        function visitSuperCallInBody(node) {
             return visitCallExpressionWithPotentialCapturedThisAssignment(node, /*assignToCapturedThis*/ false);
         }
         function visitCallExpressionWithPotentialCapturedThisAssignment(node, assignToCapturedThis) {
@@ -146231,20 +146368,31 @@ var ts;
         codefix.registerCodeFix({
             errorCodes: errorCodes,
             getCodeActions: function getCodeActionsToAddConvertToUnknownForNonOverlappingTypes(context) {
-                var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return makeChange(t, context.sourceFile, context.span.start); });
+                var assertion = getAssertion(context.sourceFile, context.span.start);
+                if (assertion === undefined)
+                    return undefined;
+                var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return makeChange(t, context.sourceFile, assertion); });
                 return [codefix.createCodeFixAction(fixId, changes, ts.Diagnostics.Add_unknown_conversion_for_non_overlapping_types, fixId, ts.Diagnostics.Add_unknown_to_all_conversions_of_non_overlapping_types)];
             },
             fixIds: [fixId],
-            getAllCodeActions: function (context) { return codefix.codeFixAll(context, errorCodes, function (changes, diag) { return makeChange(changes, diag.file, diag.start); }); },
+            getAllCodeActions: function (context) { return codefix.codeFixAll(context, errorCodes, function (changes, diag) {
+                var assertion = getAssertion(diag.file, diag.start);
+                if (assertion) {
+                    makeChange(changes, diag.file, assertion);
+                }
+            }); },
         });
-        function makeChange(changeTracker, sourceFile, pos) {
-            var token = ts.getTokenAtPosition(sourceFile, pos);
-            var assertion = ts.Debug.checkDefined(ts.findAncestor(token, function (n) { return ts.isAsExpression(n) || ts.isTypeAssertionExpression(n); }), "Expected to find an assertion expression");
+        function makeChange(changeTracker, sourceFile, assertion) {
             var replacement = ts.isAsExpression(assertion)
                 ? ts.factory.createAsExpression(assertion.expression, ts.factory.createKeywordTypeNode(154 /* UnknownKeyword */))
                 : ts.factory.createTypeAssertion(ts.factory.createKeywordTypeNode(154 /* UnknownKeyword */), assertion.expression);
             changeTracker.replaceNode(sourceFile, assertion.expression, replacement);
         }
+        function getAssertion(sourceFile, pos) {
+            if (ts.isInJSFile(sourceFile))
+                return undefined;
+            return ts.findAncestor(ts.getTokenAtPosition(sourceFile, pos), function (n) { return ts.isAsExpression(n) || ts.isTypeAssertionExpression(n); });
+        }
     })(codefix = ts.codefix || (ts.codefix = {}));
 })(ts || (ts = {}));
 /* @internal */