DRAFT: Support renames with template literals

Author: IllusionMH

src/compiler/utilities.ts

@@ -1847,6 +1847,10 @@ namespace ts {
         return getSourceTextOfNodeFromSourceFile(sourceFile, str).charCodeAt(0) === CharacterCodes.doubleQuote;
     }
 
+    export function isSingleOrDoubleQuoteOrBacktick(charCode: number) {
+        return charCode === CharacterCodes.singleQuote || charCode === CharacterCodes.doubleQuote || charCode === CharacterCodes.backtick;
+    }
+
     export function getDeclarationOfExpando(node: Node): Node | undefined {
         if (!node.parent) {
             return undefined;
@@ -3236,6 +3240,14 @@ namespace ts {
         return isSingleOrDoubleQuote(name.charCodeAt(0));
     }
 
+    export function stripQuotesOrBacktics(name: string) {
+        const length = name.length;
+        if (length >= 2 && name.charCodeAt(0) === name.charCodeAt(length - 1) && isSingleOrDoubleQuoteOrBacktick(name.charCodeAt(0))) {
+            return name.substring(1, length - 1);
+        }
+        return name;
+    }
+
     function getReplacement(c: string, offset: number, input: string) {
         if (c.charCodeAt(0) === CharacterCodes.nullCharacter) {
             const lookAhead = input.charCodeAt(offset + c.length);

src/services/findAllReferences.ts

@@ -448,7 +448,7 @@ namespace ts.FindAllReferences {
     function getTextSpan(node: Node, sourceFile: SourceFile, endNode?: Node): TextSpan {
         let start = node.getStart(sourceFile);
         let end = (endNode || node).getEnd();
-        if (node.kind === SyntaxKind.StringLiteral) {
+        if (isStringLiteralLike(node)) {
             Debug.assert(endNode === undefined);
             start += 1;
             end -= 1;
@@ -1234,8 +1234,9 @@ namespace ts.FindAllReferences.Core {
             case SyntaxKind.Identifier:
                 return (node as Identifier).text.length === searchSymbolName.length;
 
+            case SyntaxKind.NoSubstitutionTemplateLiteral:
             case SyntaxKind.StringLiteral: {
-                const str = node as StringLiteral;
+                const str = node as StringLiteralLike;
                 return (isLiteralNameOfPropertyDeclarationOrIndexAccess(str) || isNameOfModuleDeclaration(node) || isExpressionOfExternalModuleImportEqualsDeclaration(node) || (isCallExpression(node.parent) && isBindableObjectDefinePropertyCall(node.parent) && node.parent.arguments[1] === node)) &&
                     str.text.length === searchSymbolName.length;
             }

src/services/rename.ts

@@ -31,7 +31,7 @@ namespace ts.Rename {
 
         const kind = SymbolDisplay.getSymbolKind(typeChecker, symbol, node);
         const specifierName = (isImportOrExportSpecifierName(node) || isStringOrNumericLiteralLike(node) && node.parent.kind === SyntaxKind.ComputedPropertyName)
-            ? stripQuotes(getTextOfIdentifierOrLiteral(node))
+            ? stripQuotesOrBacktics(getTextOfIdentifierOrLiteral(node))
             : undefined;
         const displayName = specifierName || typeChecker.symbolToString(symbol);
         const fullDisplayName = specifierName || typeChecker.getFullyQualifiedName(symbol);
@@ -81,7 +81,7 @@ namespace ts.Rename {
     function createTriggerSpanForNode(node: Node, sourceFile: SourceFile) {
         let start = node.getStart(sourceFile);
         let width = node.getWidth(sourceFile);
-        if (node.kind === SyntaxKind.StringLiteral) {
+        if (isStringLiteralLike(node)) {
             // Exclude the quotes
             start += 1;
             width -= 2;
@@ -93,6 +93,7 @@ namespace ts.Rename {
         switch (node.kind) {
             case SyntaxKind.Identifier:
             case SyntaxKind.StringLiteral:
+            case SyntaxKind.NoSubstitutionTemplateLiteral:
             case SyntaxKind.ThisKeyword:
                 return true;
             case SyntaxKind.NumericLiteral:

src/services/services.ts

@@ -2227,6 +2227,7 @@ namespace ts {
     function getContainingObjectLiteralElementWorker(node: Node): ObjectLiteralElement | undefined {
         switch (node.kind) {
             case SyntaxKind.StringLiteral:
+            case SyntaxKind.NoSubstitutionTemplateLiteral:
             case SyntaxKind.NumericLiteral:
                 if (node.parent.kind === SyntaxKind.ComputedPropertyName) {
                     return isObjectLiteralElement(node.parent.parent) ? node.parent.parent : undefined;

src/services/utilities.ts

@@ -267,7 +267,7 @@ namespace ts {
             isFunctionLike(node.parent) && (<FunctionLikeDeclaration>node.parent).name === node;
     }
 
-    export function isLiteralNameOfPropertyDeclarationOrIndexAccess(node: StringLiteral | NumericLiteral): boolean {
+    export function isLiteralNameOfPropertyDeclarationOrIndexAccess(node: StringLiteral | NumericLiteral | NoSubstitutionTemplateLiteral): boolean {
         switch (node.parent.kind) {
             case SyntaxKind.PropertyDeclaration:
             case SyntaxKind.PropertySignature:

tests/cases/fourslash/renameComputedPropertiesTemplateLiterals.ts

@@ -0,0 +1,24 @@
+/// <reference path='fourslash.ts' />
+
+////var o = {
+////    [|[`[|{| "contextRangeIndex": 0 |}tplProp|]`]: 0|],
+////    [|['[|{| "contextRangeIndex": 2 |}strProp|]']: 0|]
+////};
+////
+////o = {
+////    [|[`[|{| "contextRangeIndex": 4 |}tplProp|]`]: 1|],
+////    [|['[|{| "contextRangeIndex": 6 |}strProp|]']: 1|]
+////};
+////
+////o.[|tplProp|];
+////o['[|tplProp|]'];
+////o["[|tplProp|]"];
+////o[`[|tplProp|]`];
+////
+////o.[|strProp|];
+////o['[|strProp|]'];
+////o["[|strProp|]"];
+////o[`[|strProp|]`];
+
+verify.rangesWithSameTextAreRenameLocations("tplProp");
+verify.rangesWithSameTextAreRenameLocations("strProp");