Merge remote-tracking branch 'upstream/master'

* upstream/master:
  Use control flow analysis to check 'super(...)' call before 'this' access (microsoft#38612)
  LEGO: check in for master to temporary branch.
  Make `processTaggedTemplateExpression` visit a returned node
  goToDefinition: find only the value if it's the RHS of an assignment
  Fix regression organize imports duplicates comments (microsoft#38599)
  Fix crash in JS declaration emit (microsoft#38508)

Author: cangSDARM

src/compiler/binder.ts

@@ -1003,7 +1003,7 @@ namespace ts {
             return initFlowNode({ flags: FlowFlags.SwitchClause, antecedent, switchStatement, clauseStart, clauseEnd });
         }
 
-        function createFlowMutation(flags: FlowFlags, antecedent: FlowNode, node: Node): FlowNode {
+        function createFlowMutation(flags: FlowFlags, antecedent: FlowNode, node: Expression | VariableDeclaration | ArrayBindingElement): FlowNode {
             setFlowNodeReferenced(antecedent);
             const result = initFlowNode({ flags, antecedent, node });
             if (currentExceptionTarget) {
@@ -1359,7 +1359,7 @@ namespace ts {
             // is potentially an assertion and is therefore included in the control flow.
             if (node.expression.kind === SyntaxKind.CallExpression) {
                 const call = <CallExpression>node.expression;
-                if (isDottedName(call.expression)) {
+                if (isDottedName(call.expression) && call.expression.kind !== SyntaxKind.SuperKeyword) {
                     currentFlow = createFlowCall(currentFlow, call);
                 }
             }
@@ -1765,6 +1765,9 @@ namespace ts {
                 }
                 else {
                     bindEachChild(node);
+                    if (node.expression.kind === SyntaxKind.SuperKeyword) {
+                        currentFlow = createFlowCall(currentFlow, node);
+                    }
                 }
             }
             if (node.expression.kind === SyntaxKind.PropertyAccessExpression) {
@@ -2496,6 +2499,9 @@ namespace ts {
                         node.flowNode = currentFlow;
                     }
                     return checkStrictModeIdentifier(<Identifier>node);
+                case SyntaxKind.SuperKeyword:
+                    node.flowNode = currentFlow;
+                    break;
                 case SyntaxKind.PrivateIdentifier:
                     return checkPrivateIdentifier(node as PrivateIdentifier);
                 case SyntaxKind.PropertyAccessExpression:

src/compiler/checker.ts

@@ -911,6 +911,7 @@ namespace ts {
         const sharedFlowNodes: FlowNode[] = [];
         const sharedFlowTypes: FlowType[] = [];
         const flowNodeReachable: (boolean | undefined)[] = [];
+        const flowNodePostSuper: (boolean | undefined)[] = [];
         const potentialThisCollisions: Node[] = [];
         const potentialNewTargetCollisions: Node[] = [];
         const potentialWeakMapCollisions: Node[] = [];
@@ -5952,6 +5953,7 @@ namespace ts {
                     }
                 }
 
+
                 // Synthesize declarations for a symbol - might be an Interface, a Class, a Namespace, a Type, a Variable (const, let, or var), an Alias
                 // or a merge of some number of those.
                 // An interesting challenge is ensuring that when classes merge with namespaces and interfaces, is keeping
@@ -6320,7 +6322,10 @@ namespace ts {
                     const baseTypes = getBaseTypes(classType);
                     const implementsTypes = getImplementsTypes(classType);
                     const staticType = getTypeOfSymbol(symbol);
-                    const staticBaseType = getBaseConstructorTypeOfClass(staticType as InterfaceType);
+                    const isClass = !!staticType.symbol?.valueDeclaration && isClassLike(staticType.symbol.valueDeclaration);
+                    const staticBaseType = isClass
+                        ? getBaseConstructorTypeOfClass(staticType as InterfaceType)
+                        : anyType;
                     const heritageClauses = [
                         ...!length(baseTypes) ? [] : [createHeritageClause(SyntaxKind.ExtendsKeyword, map(baseTypes, b => serializeBaseType(b, staticBaseType, localName)))],
                         ...!length(implementsTypes) ? [] : [createHeritageClause(SyntaxKind.ImplementsKeyword, map(implementsTypes, b => serializeBaseType(b, staticBaseType, localName)))]
@@ -6356,7 +6361,17 @@ namespace ts {
                     const staticMembers = flatMap(
                         filter(getPropertiesOfType(staticType), p => !(p.flags & SymbolFlags.Prototype) && p.escapedName !== "prototype" && !isNamespaceMember(p)),
                         p => serializePropertySymbolForClass(p, /*isStatic*/ true, staticBaseType));
-                    const constructors = serializeSignatures(SignatureKind.Construct, staticType, baseTypes[0], SyntaxKind.Constructor) as ConstructorDeclaration[];
+                    // When we encounter an `X.prototype.y` assignment in a JS file, we bind `X` as a class regardless as to whether
+                    // the value is ever initialized with a class or function-like value. For cases where `X` could never be
+                    // created via `new`, we will inject a `private constructor()` declaration to indicate it is not createable.
+                    const isNonConstructableClassLikeInJsFile =
+                        !isClass &&
+                        !!symbol.valueDeclaration &&
+                        isInJSFile(symbol.valueDeclaration) &&
+                        !some(getSignaturesOfType(staticType, SignatureKind.Construct));
+                    const constructors = isNonConstructableClassLikeInJsFile ?
+                        [createConstructor(/*decorators*/ undefined, createModifiersFromModifierFlags(ModifierFlags.Private), [], /*body*/ undefined)] :
+                        serializeSignatures(SignatureKind.Construct, staticType, baseTypes[0], SyntaxKind.Constructor) as ConstructorDeclaration[];
                     for (const c of constructors) {
                         // A constructor's return type and type parameters are supposed to be controlled by the enclosing class declaration
                         // `signatureToSignatureDeclarationHelper` appends them regardless, so for now we delete them here
@@ -20137,7 +20152,7 @@ namespace ts {
                     noCacheCheck = false;
                 }
                 if (flags & (FlowFlags.Assignment | FlowFlags.Condition | FlowFlags.ArrayMutation)) {
-                    flow = (<FlowAssignment | FlowCondition | FlowArrayMutation | PreFinallyFlow>flow).antecedent;
+                    flow = (<FlowAssignment | FlowCondition | FlowArrayMutation>flow).antecedent;
                 }
                 else if (flags & FlowFlags.Call) {
                     const signature = getEffectsSignature((<FlowCall>flow).node);
@@ -20187,6 +20202,51 @@ namespace ts {
             }
         }
 
+        // Return true if the given flow node is preceded by a 'super(...)' call in every possible code path
+        // leading to the node.
+        function isPostSuperFlowNode(flow: FlowNode, noCacheCheck: boolean): boolean {
+            while (true) {
+                const flags = flow.flags;
+                if (flags & FlowFlags.Shared) {
+                    if (!noCacheCheck) {
+                        const id = getFlowNodeId(flow);
+                        const postSuper = flowNodePostSuper[id];
+                        return postSuper !== undefined ? postSuper : (flowNodePostSuper[id] = isPostSuperFlowNode(flow, /*noCacheCheck*/ true));
+                    }
+                    noCacheCheck = false;
+                }
+                if (flags & (FlowFlags.Assignment | FlowFlags.Condition | FlowFlags.ArrayMutation | FlowFlags.SwitchClause)) {
+                    flow = (<FlowAssignment | FlowCondition | FlowArrayMutation | FlowSwitchClause>flow).antecedent;
+                }
+                else if (flags & FlowFlags.Call) {
+                    if ((<FlowCall>flow).node.expression.kind === SyntaxKind.SuperKeyword) {
+                        return true;
+                    }
+                    flow = (<FlowCall>flow).antecedent;
+                }
+                else if (flags & FlowFlags.BranchLabel) {
+                    // A branching point is post-super if every branch is post-super.
+                    return every((<FlowLabel>flow).antecedents, f => isPostSuperFlowNode(f, /*noCacheCheck*/ false));
+                }
+                else if (flags & FlowFlags.LoopLabel) {
+                    // A loop is post-super if the control flow path that leads to the top is post-super.
+                    flow = (<FlowLabel>flow).antecedents![0];
+                }
+                else if (flags & FlowFlags.ReduceLabel) {
+                    const target = (<FlowReduceLabel>flow).target;
+                    const saveAntecedents = target.antecedents;
+                    target.antecedents = (<FlowReduceLabel>flow).antecedents;
+                    const result = isPostSuperFlowNode((<FlowReduceLabel>flow).antecedent, /*noCacheCheck*/ false);
+                    target.antecedents = saveAntecedents;
+                    return result;
+                }
+                else {
+                    // Unreachable nodes are considered post-super to silence errors
+                    return !!(flags & FlowFlags.Unreachable);
+                }
+            }
+        }
+
         function getFlowTypeOfReference(reference: Node, declaredType: Type, initialType = declaredType, flowContainer?: Node, couldBeUninitialized?: boolean) {
             let key: string | undefined;
             let keySet = false;
@@ -21586,31 +21646,10 @@ namespace ts {
             }
         }
 
-        function findFirstSuperCall(n: Node): SuperCall | undefined {
-            if (isSuperCall(n)) {
-                return n;
-            }
-            else if (isFunctionLike(n)) {
-                return undefined;
-            }
-            return forEachChild(n, findFirstSuperCall);
-        }
-
-        /**
-         * Return a cached result if super-statement is already found.
-         * Otherwise, find a super statement in a given constructor function and cache the result in the node-links of the constructor
-         *
-         * @param constructor constructor-function to look for super statement
-         */
-        function getSuperCallInConstructor(constructor: ConstructorDeclaration): SuperCall | undefined {
-            const links = getNodeLinks(constructor);
-
-            // Only trying to find super-call if we haven't yet tried to find one.  Once we try, we will record the result
-            if (links.hasSuperCall === undefined) {
-                links.superCall = findFirstSuperCall(constructor.body!);
-                links.hasSuperCall = links.superCall ? true : false;
-            }
-            return links.superCall!;
+        function findFirstSuperCall(node: Node): SuperCall | undefined {
+            return isSuperCall(node) ? node :
+                isFunctionLike(node) ? undefined :
+                forEachChild(node, findFirstSuperCall);
         }
 
         /**
@@ -21633,17 +21672,7 @@ namespace ts {
             // If a containing class does not have extends clause or the class extends null
             // skip checking whether super statement is called before "this" accessing.
             if (baseTypeNode && !classDeclarationExtendsNull(containingClassDecl)) {
-                const superCall = getSuperCallInConstructor(<ConstructorDeclaration>container);
-
-                // We should give an error in the following cases:
-                //      - No super-call
-                //      - "this" is accessing before super-call.
-                //          i.e super(this)
-                //              this.x; super();
-                // We want to make sure that super-call is done before accessing "this" so that
-                // "this" is not accessed as a parameter of the super-call.
-                if (!superCall || superCall.end > node.pos) {
-                    // In ES6, super inside constructor of class-declaration has to precede "this" accessing
+                if (node.flowNode && !isPostSuperFlowNode(node.flowNode, /*noCacheCheck*/ false)) {
                     error(node, diagnosticMessage);
                 }
             }
@@ -21868,7 +21897,8 @@ namespace ts {
         function checkSuperExpression(node: Node): Type {
             const isCallExpression = node.parent.kind === SyntaxKind.CallExpression && (<CallExpression>node.parent).expression === node;
 
-            let container = getSuperContainer(node, /*stopOnFunctions*/ true);
+            const immediateContainer = getSuperContainer(node, /*stopOnFunctions*/ true);
+            let container = immediateContainer;
             let needToCaptureLexicalThis = false;
 
             // adjust the container reference in case if super is used inside arrow functions with arbitrarily deep nesting
@@ -21904,7 +21934,7 @@ namespace ts {
                 return errorType;
             }
 
-            if (!isCallExpression && container.kind === SyntaxKind.Constructor) {
+            if (!isCallExpression && immediateContainer.kind === SyntaxKind.Constructor) {
                 checkThisBeforeSuper(node, container, Diagnostics.super_must_be_called_before_accessing_a_property_of_super_in_the_constructor_of_a_derived_class);
             }
 
@@ -29901,7 +29931,7 @@ namespace ts {
             if (getClassExtendsHeritageElement(containingClassDecl)) {
                 captureLexicalThis(node.parent, containingClassDecl);
                 const classExtendsNull = classDeclarationExtendsNull(containingClassDecl);
-                const superCall = getSuperCallInConstructor(node);
+                const superCall = findFirstSuperCall(node.body!);
                 if (superCall) {
                     if (classExtendsNull) {
                         error(superCall, Diagnostics.A_constructor_cannot_contain_a_super_call_when_its_class_extends_null);

src/compiler/core.ts

@@ -150,7 +150,7 @@ namespace ts {
      * returns a falsey value, then returns false.
      * If no such value is found, the callback is applied to each element of array and `true` is returned.
      */
-    export function every<T>(array: readonly T[], callback: (element: T, index: number) => boolean): boolean {
+    export function every<T>(array: readonly T[] | undefined, callback: (element: T, index: number) => boolean): boolean {
         if (array) {
             for (let i = 0; i < array.length; i++) {
                 if (!callback(array[i], i)) {

src/compiler/transformers/es2015.ts

@@ -2583,7 +2583,7 @@ namespace ts {
                     && i < numInitialPropertiesWithoutYield) {
                     numInitialPropertiesWithoutYield = i;
                 }
-                if (property.name!.kind === SyntaxKind.ComputedPropertyName) {
+                if (Debug.checkDefined(property.name).kind === SyntaxKind.ComputedPropertyName) {
                     numInitialProperties = i;
                     break;
                 }

src/compiler/transformers/taggedTemplate.ts

@@ -8,7 +8,7 @@ namespace ts {
     export function processTaggedTemplateExpression(
         context: TransformationContext,
         node: TaggedTemplateExpression,
-        visitor: ((node: Node) => VisitResult<Node>) | undefined,
+        visitor: Visitor,
         currentSourceFile: SourceFile,
         recordTaggedTemplateString: (temp: Identifier) => void,
         level: ProcessLevel) {
@@ -24,7 +24,9 @@ namespace ts {
         const rawStrings: Expression[] = [];
         const template = node.template;
 
-        if (level === ProcessLevel.LiftRestriction && !hasInvalidEscape(template)) return node;
+        if (level === ProcessLevel.LiftRestriction && !hasInvalidEscape(template)) {
+            return visitEachChild(node, visitor, context);
+        }
 
         if (isNoSubstitutionTemplateLiteral(template)) {
             cookedStrings.push(createTemplateCooked(template));

src/compiler/types.ts

@@ -2799,34 +2799,21 @@ namespace ts {
     }
 
     export type FlowNode =
-        | AfterFinallyFlow
-        | PreFinallyFlow
         | FlowStart
         | FlowLabel
         | FlowAssignment
         | FlowCall
         | FlowCondition
         | FlowSwitchClause
-        | FlowArrayMutation;
+        | FlowArrayMutation
+        | FlowCall
+        | FlowReduceLabel;
 
     export interface FlowNodeBase {
         flags: FlowFlags;
         id?: number;     // Node id used by flow type cache in checker
     }
 
-    export interface FlowLock {
-        locked?: boolean;
-    }
-
-    export interface AfterFinallyFlow extends FlowNodeBase, FlowLock {
-        antecedent: FlowNode;
-    }
-
-    export interface PreFinallyFlow extends FlowNodeBase {
-        antecedent: FlowNode;
-        lock: FlowLock;
-    }
-
     // FlowStart represents the start of a control flow. For a function expression or arrow
     // function, the node property references the function (which in turn has a flowNode
     // property for the containing control flow).
@@ -4329,8 +4316,6 @@ namespace ts {
         resolvedJsxElementAttributesType?: Type;  // resolved element attributes type of a JSX openinglike element
         resolvedJsxElementAllAttributesType?: Type;  // resolved all element attributes type of a JSX openinglike element
         resolvedJSDocType?: Type;                   // Resolved type of a JSDoc type reference
-        hasSuperCall?: boolean;           // recorded result when we try to find super-call. We only try to find one if this flag is undefined, indicating that we haven't made an attempt.
-        superCall?: SuperCall;  // Cached first super-call found in the constructor. Used in checking whether super is called before this-accessing
         switchTypes?: Type[];             // Cached array of switch case expression types
         jsxNamespace?: Symbol | false;          // Resolved jsx namespace symbol for this node
         contextFreeType?: Type;          // Cached context-free type used by the first pass of inference; used when a function's return is partially contextually sensitive