All to find all references for constructors

Andy Hanson · Andy Hanson · commit 1ccabe48671f · 2016-08-25T11:04:25.000-07:00
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
@@ -8750,7 +8750,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
@@ -300,8 +300,8 @@ namespace ts {
                     }
                 }
                 // For syntactic classifications, all trivia are classcified together, including jsdoc comments.
-                // For that to work, the jsdoc comments should still be the leading trivia of the first child. 
-                // Restoring the scanner position ensures that. 
+                // For that to work, the jsdoc comments should still be the leading trivia of the first child.
+                // Restoring the scanner position ensures that.
                 pos = this.pos;
                 forEachChild(this, processNode, processNodes);
                 if (pos < this.end) {
@@ -2789,18 +2789,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) {
@@ -4715,7 +4738,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)
@@ -6009,6 +6034,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);
             }
@@ -6053,7 +6079,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);
@@ -6079,7 +6109,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).
@@ -6093,7 +6124,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();
 
@@ -6431,12 +6462,87 @@ 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 = findStaticConstructorCalls(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));
+                    }
+                }
+
+                /** Find calls to `new this()` in static methods in the class where a constructor is defined. */
+                function findStaticConstructorCalls(referenceSymbol: Symbol, referenceLocation: ClassLikeDeclaration): Node[] {
+                    const result: Node[] = [];
+                    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];
@@ -6463,6 +6569,8 @@ namespace ts {
                 }
             }
 
+
+
             function getReferencesForSuperKeyword(superKeyword: Node): ReferencedSymbol[] {
                 let searchSpaceNode = getSuperContainer(superKeyword, /*stopOnFunctions*/ false);
                 if (!searchSpaceNode) {
@@ -6810,8 +6918,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;
                 }
 
@@ -6822,6 +6930,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
@@ -8343,6 +8456,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,40 @@
+/// <reference path="fourslash.ts" />
+
+// @Filename: a.ts
+////export class C {
+////    [|constructor|](){}
+////    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 [r0, ...rest] = test.ranges();
+verify.referencesOf(r0, rest);

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