Allow to find all references for constructors

Andy Hanson · Andy Hanson · commit 3f126a52f9b9 · 2016-08-26T09:19:48.000-07:00
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
@@ -8752,7 +8752,7 @@ namespace ts {
             // The location isn't a reference to the given symbol, meaning we're being asked
             // a hypothetical question of what type the symbol would have if there was a reference
             // to it at the given location. Since we have no control flow information for the
-            // hypotherical reference (control flow information is created and attached by the
+            // hypothetical reference (control flow information is created and attached by the
             // binder), we simply return the declared type of the symbol.
             return getTypeOfSymbol(symbol);
         }
diff --git a/src/services/services.ts b/src/services/services.ts
@@ -2788,18 +2788,41 @@ namespace ts {
         return node && node.parent && node.parent.kind === SyntaxKind.PropertyAccessExpression && (<PropertyAccessExpression>node.parent).name === node;
     }
 
+    function climbPastPropertyAccess(node: Node) {
+        return isRightSideOfPropertyAccess(node) ? node.parent : node;
+    }
+
     function isCallExpressionTarget(node: Node): boolean {
-        if (isRightSideOfPropertyAccess(node)) {
-            node = node.parent;
-        }
-        return node && node.parent && node.parent.kind === SyntaxKind.CallExpression && (<CallExpression>node.parent).expression === node;
+        return isCallOrNewExpressionTarget(node, SyntaxKind.CallExpression);
     }
 
     function isNewExpressionTarget(node: Node): boolean {
-        if (isRightSideOfPropertyAccess(node)) {
-            node = node.parent;
+        return isCallOrNewExpressionTarget(node, SyntaxKind.NewExpression);
+    }
+
+    function isCallOrNewExpressionTarget(node: Node, kind: SyntaxKind) {
+        const target = climbPastPropertyAccess(node);
+        return target && target.parent && target.parent.kind === kind && (<CallExpression>target.parent).expression === target;
+    }
+
+    /** Get `C` given `N` if `N` is in the position `class C extends N` */
+    function tryGetClassExtendingNode(node: Node): ClassLikeDeclaration | undefined {
+        const target = climbPastPropertyAccess(node);
+
+        const expr = target.parent;
+        if (expr.kind !== SyntaxKind.ExpressionWithTypeArguments) {
+            return;
+        }
+
+        const heritageClause = expr.parent;
+        if (heritageClause.kind !== SyntaxKind.HeritageClause) {
+            return;
+        }
+
+        const classNode = <ClassLikeDeclaration>heritageClause.parent;
+        if (getHeritageClause(classNode.heritageClauses, SyntaxKind.ExtendsKeyword) === heritageClause) {
+            return classNode;
         }
-        return node && node.parent && node.parent.kind === SyntaxKind.NewExpression && (<CallExpression>node.parent).expression === node;
     }
 
     function isNameOfModuleDeclaration(node: Node) {
@@ -4714,7 +4737,9 @@ namespace ts {
                         if (functionDeclaration.kind === SyntaxKind.Constructor) {
                             // show (constructor) Type(...) signature
                             symbolKind = ScriptElementKind.constructorImplementationElement;
-                            addPrefixForAnyFunctionOrVar(type.symbol, symbolKind);
+                            // For a constructor, `type` will be unknown.
+                            const showSymbol = symbol.declarations[0].kind === SyntaxKind.Constructor ? symbol.parent : type.symbol;
+                            addPrefixForAnyFunctionOrVar(showSymbol, symbolKind);
                         }
                         else {
                             // (function/method) symbol(..signature)
@@ -6008,6 +6033,7 @@ namespace ts {
                 case SyntaxKind.Identifier:
                 case SyntaxKind.ThisKeyword:
                 // case SyntaxKind.SuperKeyword: TODO:GH#9268
+                case SyntaxKind.ConstructorKeyword:
                 case SyntaxKind.StringLiteral:
                     return getReferencedSymbolsForNode(node, program.getSourceFiles(), findInStrings, findInComments);
             }
@@ -6052,7 +6078,11 @@ namespace ts {
                 return getReferencesForSuperKeyword(node);
             }
 
-            const symbol = typeChecker.getSymbolAtLocation(node);
+            const isConstructor = node.kind === SyntaxKind.ConstructorKeyword;
+
+            // `getSymbolAtLocation` normally returns the symbol of the class when given the constructor keyword,
+            // so we have to specify that we want the constructor symbol.
+            let symbol = isConstructor ? node.parent.symbol : typeChecker.getSymbolAtLocation(node);
 
             if (!symbol && node.kind === SyntaxKind.StringLiteral) {
                 return getReferencesForStringLiteral(<StringLiteral>node, sourceFiles);
@@ -6078,7 +6108,8 @@ namespace ts {
 
             // Get the text to search for.
             // Note: if this is an external module symbol, the name doesn't include quotes.
-            const declaredName = stripQuotes(getDeclaredName(typeChecker, symbol, node));
+            const nameSymbol = isConstructor ? symbol.parent : symbol; // A constructor is referenced using the name of its class.
+            const declaredName = stripQuotes(getDeclaredName(typeChecker, nameSymbol, node));
 
             // Try to get the smallest valid scope that we can limit our search to;
             // otherwise we'll need to search globally (i.e. include each file).
@@ -6092,7 +6123,7 @@ namespace ts {
                 getReferencesInNode(scope, symbol, declaredName, node, searchMeaning, findInStrings, findInComments, result, symbolToIndex);
             }
             else {
-                const internedName = getInternedName(symbol, node, declarations);
+                const internedName = isConstructor ? declaredName : getInternedName(symbol, node, declarations);
                 for (const sourceFile of sourceFiles) {
                     cancellationToken.throwIfCancellationRequested();
 
@@ -6430,12 +6461,98 @@ namespace ts {
                                 const referencedSymbol = getReferencedSymbol(shorthandValueSymbol);
                                 referencedSymbol.references.push(getReferenceEntryFromNode(referenceSymbolDeclaration.name));
                             }
+                            else if (searchLocation.kind === SyntaxKind.ConstructorKeyword) {
+                                findAdditionalConstructorReferences(referenceSymbol, referenceLocation);
+                            }
                         }
                     });
                 }
 
                 return;
 
+                /** Adds references when a constructor is used with `new this()` in its own class and `super()` calls in subclasses.  */
+                function findAdditionalConstructorReferences(referenceSymbol: Symbol, referenceLocation: Node): void {
+                    const searchClassSymbol = searchSymbol.parent;
+                    Debug.assert(isClassLike(searchClassSymbol.valueDeclaration));
+
+                    const referenceClass = referenceLocation.parent;
+                    if (referenceSymbol === searchClassSymbol && isClassLike(referenceClass)) {
+                        // This is the class declaration containing the constructor.
+                        const calls = findOwnConstructorCalls(referenceSymbol, <ClassLikeDeclaration>referenceClass);
+                        addReferences(calls);
+                    }
+                    else {
+                        // If this class appears in `extends C`, then the extending class' "super" calls are references.
+                        const classExtending = tryGetClassExtendingNode(referenceLocation);
+                        if (classExtending && isClassLike(classExtending)) {
+                            if (getRelatedSymbol([searchClassSymbol], referenceSymbol, referenceLocation)) {
+                                const supers = superConstructorAccesses(classExtending);
+                                addReferences(supers);
+                            }
+                        }
+                    }
+                }
+
+                function addReferences(references: Node[]): void {
+                    if (references.length) {
+                        const referencedSymbol = getReferencedSymbol(searchSymbol);
+                        addRange(referencedSymbol.references, map(references, getReferenceEntryFromNode));
+                    }
+                }
+
+                /** `referenceLocation` is the class where the constructor was defined.
+                 * Reference the constructor and all calls to `new this()`.
+                 */
+                function findOwnConstructorCalls(referenceSymbol: Symbol, referenceLocation: ClassLikeDeclaration): Node[] {
+                    const result: Node[] = [];
+
+                    for (const decl of referenceSymbol.members["__constructor"].declarations) {
+                        Debug.assert(decl.kind === SyntaxKind.Constructor);
+                        const ctrKeyword = decl.getChildAt(0);
+                        Debug.assert(ctrKeyword.kind === SyntaxKind.ConstructorKeyword);
+                        result.push(ctrKeyword);
+                    }
+
+                    forEachProperty(referenceSymbol.exports, member => {
+                        const decl = member.valueDeclaration;
+                        if (decl && decl.kind === SyntaxKind.MethodDeclaration) {
+                            const body = (<MethodDeclaration>decl).body;
+                            if (body) {
+                                forEachDescendant(body, SyntaxKind.ThisKeyword, thisKeyword => {
+                                    if (isNewExpressionTarget(thisKeyword)) {
+                                        result.push(thisKeyword);
+                                    }
+                                });
+                            }
+                        }
+                    });
+
+                    return result;
+                }
+
+                /** Find references to `super` in the constructor of an extending class.  */
+                function superConstructorAccesses(cls: ClassLikeDeclaration): Node[] {
+                    const symbol = cls.symbol;
+                    const ctr = symbol.members["__constructor"];
+                    if (!ctr) {
+                        return [];
+                    }
+
+                    const result: Node[] = [];
+                    for (const decl of ctr.declarations) {
+                        Debug.assert(decl.kind === SyntaxKind.Constructor);
+                        const body = (<ConstructorDeclaration>decl).body;
+                        if (body) {
+                            forEachDescendant(body, SyntaxKind.SuperKeyword, node => {
+                                if (isCallExpressionTarget(node)) {
+                                    result.push(node);
+                                }
+                            });
+                        }
+                    };
+                    return result;
+                }
+
                 function getReferencedSymbol(symbol: Symbol): ReferencedSymbol {
                     const symbolId = getSymbolId(symbol);
                     let index = symbolToIndex[symbolId];
@@ -6809,8 +6926,8 @@ namespace ts {
                 }
             }
 
-            function getRelatedSymbol(searchSymbols: Symbol[], referenceSymbol: Symbol, referenceLocation: Node): Symbol {
-                if (searchSymbols.indexOf(referenceSymbol) >= 0) {
+            function getRelatedSymbol(searchSymbols: Symbol[], referenceSymbol: Symbol, referenceLocation: Node): Symbol | undefined {
+                if (contains(searchSymbols, referenceSymbol)) {
                     return referenceSymbol;
                 }
 
@@ -6821,6 +6938,11 @@ namespace ts {
                     return getRelatedSymbol(searchSymbols, aliasSymbol, referenceLocation);
                 }
 
+                // If we are in a constructor and we didn't find the symbol yet, we should try looking for the constructor instead.
+                if (isNewExpressionTarget(referenceLocation) && referenceSymbol.members && referenceSymbol.members["__constructor"]) {
+                    return getRelatedSymbol(searchSymbols, referenceSymbol.members["__constructor"], referenceLocation.parent);
+                }
+
                 // If the reference location is in an object literal, try to get the contextual type for the
                 // object literal, lookup the property symbol in the contextual type, and use this symbol to
                 // compare to our searchSymbol
@@ -8342,6 +8464,15 @@ namespace ts {
         };
     }
 
+    function forEachDescendant(node: Node, kind: SyntaxKind, action: (node: Node) => void) {
+        forEachChild(node, child => {
+            if (child.kind === kind) {
+                action(child);
+            }
+            forEachDescendant(child, kind, action);
+        });
+    }
+
     /* @internal */
     export function getNameTable(sourceFile: SourceFile): Map<number> {
         if (!sourceFile.nameTable) {
diff --git a/tests/cases/fourslash/findAllReferencesOfConstructor.ts b/tests/cases/fourslash/findAllReferencesOfConstructor.ts
@@ -0,0 +1,43 @@
+/// <reference path="fourslash.ts" />
+
+// @Filename: a.ts
+////export class C {
+////    [|constructor|](n: number);
+////    [|constructor|]();
+////    [|constructor|](n?: number){}
+////    static f() {
+////        this.f();
+////        new [|this|]();
+////    }
+////}
+////new [|C|]();
+// Does not handle alias.
+////const D = C;
+////new D();
+
+// @Filename: b.ts
+////import { C } from "./a";
+////new [|C|]();
+
+// @Filename: c.ts
+////import { C } from "./a";
+////class D extends C {
+////    constructor() {
+////        [|super|]();
+////        super.method();
+////    }
+////    method() { super(); }
+////}
+////class E implements C {
+////    constructor() { super(); }
+////}
+
+// Works with qualified names too
+// @Filename: d.ts
+////import * as a from "./a";
+////new a.[|C|]();
+////class d extends a.C { constructor() { [|super|](); }
+
+const ranges = test.ranges();
+verify.referencesOf(ranges[0], ranges);
+verify.referencesOf(ranges[1], ranges);

Original file line number	Diff line number	Diff line change
`@@ -8752,7 +8752,7 @@ namespace ts {`
`8752`	`8752`	`// The location isn't a reference to the given symbol, meaning we're being asked`
`8753`	`8753`	`// a hypothetical question of what type the symbol would have if there was a reference`
`8754`	`8754`	`// to it at the given location. Since we have no control flow information for the`
`8755`		`- // hypotherical reference (control flow information is created and attached by the`
	`8755`	`+ // hypothetical reference (control flow information is created and attached by the`
`8756`	`8756`	`// binder), we simply return the declared type of the symbol.`
`8757`	`8757`	`return getTypeOfSymbol(symbol);`
`8758`	`8758`	`}`