Allowed non-this, non-super code before super call in derived classes with property initializers

src/compiler/checker.ts

@@ -29242,33 +29242,41 @@ namespace ts {
                         error(superCall, 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
+                    // A super call must be root-level (excluding prologue directives) 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.
-                    const superCallShouldBeFirst =
+                    const superCallShouldBeRootLevel =
                         some((<ClassDeclaration>node.parent).members, isInstancePropertyWithInitializerOrPrivateIdentifierProperty) ||
                         some(node.parameters, p => hasModifier(p, ModifierFlags.ParameterPropertyModifier));
 
-                    // Skip past any prologue directives to find the first statement
-                    // to ensure that it was a super call.
-                    if (superCallShouldBeFirst) {
-                        const statements = node.body!.statements;
-                        let superCallStatement: ExpressionStatement | undefined;
+                    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, 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 {
+                            let superCallStatement: ExpressionStatement | undefined;
 
-                        for (const statement of statements) {
-                            if (statement.kind === SyntaxKind.ExpressionStatement && isSuperCall((<ExpressionStatement>statement).expression)) {
-                                superCallStatement = <ExpressionStatement>statement;
-                                break;
+                            for (const statement of node.body!.statements) {
+                                if (isExpressionStatement(statement) && isSuperCall(skipOuterExpressions(statement.expression))) {
+                                    superCallStatement = statement;
+                                    break;
+                                }
+                                if (!isPrologueDirective(statement) && nodeImmediatelyReferencesSuperOrThis(statement)) {
+                                    break;
+                                }
                             }
-                            if (!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, 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, 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) {
@@ -29277,6 +29285,28 @@ namespace ts {
             }
         }
 
+        function superCallIsRootLevelInConstructor(superCall: Node, body: Block) {
+            let expressionParent = superCall.parent;
+
+            while (isParenthesizedExpression(expressionParent)) {
+                expressionParent = expressionParent.parent;
+            }
+
+            return expressionParent.parent === body;
+        }
+
+        function nodeImmediatelyReferencesSuperOrThis(node: Node): boolean {
+            if (node.kind === SyntaxKind.SuperKeyword || node.kind === SyntaxKind.ThisKeyword) {
+                return true;
+            }
+
+            if (isNewOrDelayedThisScope(node)) {
+                return false;
+            }
+
+            return !!forEachChild(node, nodeImmediatelyReferencesSuperOrThis);
+        }
+
         function checkAccessorDeclaration(node: AccessorDeclaration) {
             if (produceDiagnostics) {
                 // Grammar checking accessors

src/compiler/diagnosticMessages.json

@@ -1481,7 +1481,7 @@
         "category": "Error",
         "code": 2375
     },
-    "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.": {
         "category": "Error",
         "code": 2376
     },
@@ -2903,6 +2903,10 @@
         "category": "Error",
         "code": 2784
     },
+    "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.": {
+        "category": "Error",
+        "code": 2785
+    },
 
     "Import declaration '{0}' is using private name '{1}'.": {
         "category": "Error",

src/compiler/transformers/classFields.ts

@@ -631,10 +631,27 @@ namespace ts {
 
             resumeLexicalEnvironment();
 
-            let indexOfFirstStatement = 0;
+            const needsSyntheticConstructor = !constructor && isDerivedClass;
+            let indexOfFirstStatementAfterSuper = 0;
+            let indexAfterLastPrologueStatement = 0;
+            let foundSuperStatement = false;
             let statements: Statement[] = [];
 
-            if (!constructor && isDerivedClass) {
+            if (constructor) {
+                const initialDirectivesAndSuperCall = addPrologueDirectivesAndInitialSuperCall(constructor, statements, visitor);
+                indexOfFirstStatementAfterSuper = initialDirectivesAndSuperCall.indexOfFirstStatementAfterSuper;
+                indexAfterLastPrologueStatement = initialDirectivesAndSuperCall.indexAfterLastPrologueStatement;
+                foundSuperStatement = initialDirectivesAndSuperCall.foundSuperStatement;
+
+                // Add existing statements before any super call
+                statements.splice(
+                    indexAfterLastPrologueStatement,
+                    0,
+                    ...visitNodes(constructor.body!.statements, visitor, isStatement, indexAfterLastPrologueStatement, indexOfFirstStatementAfterSuper - indexAfterLastPrologueStatement - (foundSuperStatement ? 1 : 0)),
+                );
+            }
+
+            if (needsSyntheticConstructor) {
                 // Add a synthetic `super` call:
                 //
                 //  super(...arguments);
@@ -650,10 +667,9 @@ namespace ts {
                 );
             }
 
-            if (constructor) {
-                indexOfFirstStatement = addPrologueDirectivesAndInitialSuperCall(constructor, statements, visitor);
-            }
-            // Add the property initializers. Transforms this:
+            // Add the property initializers.
+            //
+            // If we don't useDefineForClassFields, we directly convert to exressions. Transforms this:
             //
             //  public x = 1;
             //
@@ -663,23 +679,57 @@ namespace ts {
             //      this.x = 1;
             //  }
             //
-            if (constructor?.body) {
-                let afterParameterProperties = findIndex(constructor.body.statements, s => !isParameterPropertyDeclaration(getOriginalNode(s), constructor), indexOfFirstStatement);
-                if (afterParameterProperties === -1) {
-                    afterParameterProperties = constructor.body.statements.length;
+            // If we do useDefineForClassFields, they'll be converted elsewhere.
+            // We instead *remove* them from the transformed output at this stage.
+            let parameterPropertyDeclarationCount = 0;
+            if (constructor && constructor.body) {
+                if (useDefineForClassFields) {
+                    statements = statements.filter(statement => !isParameterPropertyDeclaration(getOriginalNode(statement), constructor));
                 }
-                if (afterParameterProperties > indexOfFirstStatement) {
-                    if (!useDefineForClassFields) {
-                        addRange(statements, visitNodes(constructor.body.statements, visitor, isStatement, indexOfFirstStatement, afterParameterProperties - indexOfFirstStatement));
+                else {
+                    for (const statement of constructor.body.statements) {
+                        if (isParameterPropertyDeclaration(getOriginalNode(statement), constructor)) {
+                            parameterPropertyDeclarationCount++;
+                        }
+                    }
+                    if (parameterPropertyDeclarationCount > 0) {
+                        const parameterProperties = visitNodes(constructor.body.statements, visitor, isStatement, indexOfFirstStatementAfterSuper, parameterPropertyDeclarationCount);
+
+                        // If there was a super() call found, add parameter properties immediately after it
+                        if (foundSuperStatement) {
+                            addRange(statements, parameterProperties);
+                        }
+                        // If a synthetic super() call was added, add them just after it
+                        else if (needsSyntheticConstructor) {
+                            statements = addRange(
+                                [statements[0]],
+                                [
+                                    ...parameterProperties,
+                                    ...statements.slice(1),
+                                ]
+                            );
+                        }
+                        // Since there wasn't a super() call, add them to the top of the constructor
+                        else {
+                            statements = addRange(
+                                [],
+                                [
+                                    ...parameterProperties,
+                                    ...statements,
+                                ]
+                            );
+                        }
+
+                        indexOfFirstStatementAfterSuper += parameterPropertyDeclarationCount;
                     }
-                    indexOfFirstStatement = afterParameterProperties;
                 }
             }
-            addPropertyStatements(statements, properties, createThis());
 
-            // Add existing statements, skipping the initial super call.
+            addPropertyStatements(statements, properties, createThis(), getPropertyStatementInsertionIndex(needsSyntheticConstructor, foundSuperStatement, useDefineForClassFields ? 0 : parameterPropertyDeclarationCount));
+
+            // Add existing statements after the initial super call
             if (constructor) {
-                addRange(statements, visitNodes(constructor.body!.statements, visitor, isStatement, indexOfFirstStatement));
+                addRange(statements, visitNodes(constructor.body!.statements, visitBodyStatement, isStatement, indexOfFirstStatementAfterSuper));
             }
 
             statements = mergeLexicalEnvironment(statements, endLexicalEnvironment());
@@ -694,6 +744,33 @@ namespace ts {
                 ),
                 /*location*/ constructor ? constructor.body : undefined
             );
+
+            function visitBodyStatement(statement: Node) {
+                if (useDefineForClassFields && isParameterPropertyDeclaration(getOriginalNode(statement), constructor!)) {
+                    return undefined;
+                }
+
+                return visitor(statement);
+            }
+        }
+
+        /**
+         * Finds the statement to insert class properties into a class constructor.
+         *
+         * @param needsSyntheticConstructor Whether the constructor was synthesized.
+         * @param foundSuperStatement  Whether a super() statement was found in the (non-synthesized) constructor.
+         * @param parameterPropertyDeclarationCount How many parameter properties were created in the (non-synthesized) constructor.
+         */
+        function getPropertyStatementInsertionIndex(needsSyntheticConstructor: boolean, foundSuperStatement: boolean, parameterPropertyDeclarationCount: number) {
+            if (needsSyntheticConstructor) {
+                return 1;
+            }
+
+            if (!foundSuperStatement) {
+                return parameterPropertyDeclarationCount;
+            }
+
+            return undefined;
         }
 
         /**
@@ -702,8 +779,9 @@ namespace ts {
          * @param properties An array of property declarations to transform.
          * @param receiver The receiver on which each property should be assigned.
          */
-        function addPropertyStatements(statements: Statement[], properties: readonly PropertyDeclaration[], receiver: LeftHandSideExpression) {
-            for (const property of properties) {
+        function addPropertyStatements(statements: Statement[], properties: readonly PropertyDeclaration[], receiver: LeftHandSideExpression, insertionIndex?: number) {
+            for (let i = 0; i < properties.length; i += 1) {
+                const property = properties[i];
                 const expression = transformProperty(property, receiver);
                 if (!expression) {
                     continue;
@@ -712,7 +790,13 @@ namespace ts {
                 setSourceMapRange(statement, moveRangePastModifiers(property));
                 setCommentRange(statement, property);
                 setOriginalNode(statement, property);
-                statements.push(statement);
+
+                if (insertionIndex !== undefined) {
+                    statements.splice(i + insertionIndex, 0, statement);
+                }
+                else {
+                    statements.push(statement);
+                }
             }
         }