add basicly support for rename string literal type

Author: Kingwl

src/services/findAllReferences.ts

@@ -620,7 +620,7 @@ namespace ts.FindAllReferences {
             // Could not find a symbol e.g. unknown identifier
             if (!symbol) {
                 // String literal might be a property (and thus have a symbol), so do this here rather than in getReferencedSymbolsSpecial.
-                return !options.implementations && isStringLiteral(node) ? getReferencesForStringLiteral(node, sourceFiles, cancellationToken) : undefined;
+                return !options.implementations && isStringLiteral(node) ? getReferencesForStringLiteral(node, sourceFiles, checker, cancellationToken) : undefined;
             }
 
             if (symbol.escapedName === InternalSymbolName.ExportEquals) {
@@ -768,7 +768,7 @@ namespace ts.FindAllReferences {
                         // At `module.exports = ...`, reference node is `module`
                         const node = isBinaryExpression(decl) && isPropertyAccessExpression(decl.left) ? decl.left.expression :
                             isExportAssignment(decl) ? Debug.checkDefined(findChildOfKind(decl, SyntaxKind.ExportKeyword, sourceFile)) :
-                            getNameOfDeclaration(decl) || decl;
+                                getNameOfDeclaration(decl) || decl;
                         references.push(nodeEntry(node));
                     }
                 }
@@ -880,7 +880,7 @@ namespace ts.FindAllReferences {
                         Debug.assert(node.parent.name === node);
                         return SpecialSearchKind.Class;
                     }
-                    // falls through
+                // falls through
                 default:
                     return SpecialSearchKind.None;
             }
@@ -1833,7 +1833,7 @@ namespace ts.FindAllReferences {
                     if (isObjectLiteralMethod(searchSpaceNode)) {
                         break;
                     }
-                    // falls through
+                // falls through
                 case SyntaxKind.PropertyDeclaration:
                 case SyntaxKind.PropertySignature:
                 case SyntaxKind.Constructor:
@@ -1846,7 +1846,7 @@ namespace ts.FindAllReferences {
                     if (isExternalModule(<SourceFile>searchSpaceNode) || isParameterName(thisOrSuperKeyword)) {
                         return undefined;
                     }
-                    // falls through
+                // falls through
                 case SyntaxKind.FunctionDeclaration:
                 case SyntaxKind.FunctionExpression:
                     break;
@@ -1888,11 +1888,19 @@ namespace ts.FindAllReferences {
             }];
         }
 
-        function getReferencesForStringLiteral(node: StringLiteral, sourceFiles: readonly SourceFile[], cancellationToken: CancellationToken): SymbolAndEntries[] {
+        function getReferencesForStringLiteral(node: StringLiteral, sourceFiles: readonly SourceFile[], checker: TypeChecker, cancellationToken: CancellationToken): SymbolAndEntries[] {
+            const type = getContextualTypeOrAtAncestorTypeNode(node, checker);
             const references = flatMap(sourceFiles, sourceFile => {
                 cancellationToken.throwIfCancellationRequested();
-                return mapDefined(getPossibleSymbolReferenceNodes(sourceFile, node.text), ref =>
-                    isStringLiteral(ref) && ref.text === node.text ? nodeEntry(ref, EntryKind.StringLiteral) : undefined);
+                return mapDefined(getPossibleSymbolReferenceNodes(sourceFile, node.text), ref => {
+                    if (type && isStringLiteral(ref) && ref.text === node.text) {
+                        const refType = getContextualTypeOrAtAncestorTypeNode(ref, checker);
+                        if (type !== checker.getStringType() && type === refType) {
+                            return nodeEntry(ref, EntryKind.StringLiteral);
+                        }
+                    }
+                    return undefined;
+                });
             });
 
             return [{
@@ -1907,7 +1915,7 @@ namespace ts.FindAllReferences {
             const result: Symbol[] = [];
             forEachRelatedSymbol<void>(symbol, location, checker, isForRename, !(isForRename && providePrefixAndSuffixText),
                 (sym, root, base) => { result.push(base || root || sym); },
-                /*allowBaseTypes*/ () => !implementations);
+                /*allowBaseTypes*/() => !implementations);
             return result;
         }
 
@@ -2081,8 +2089,8 @@ namespace ts.FindAllReferences {
         function isImplementation(node: Node): boolean {
             return !!(node.flags & NodeFlags.Ambient) ? !(isInterfaceDeclaration(node) || isTypeAliasDeclaration(node)) :
                 (isVariableLike(node) ? hasInitializer(node) :
-                isFunctionLikeDeclaration(node) ? !!node.body :
-                isClassLike(node) || isModuleOrEnumDeclaration(node));
+                    isFunctionLikeDeclaration(node) ? !!node.body :
+                        isClassLike(node) || isModuleOrEnumDeclaration(node));
         }
 
         export function getReferenceEntriesForShorthandPropertyAssignment(node: Node, checker: TypeChecker, addReference: (node: Node) => void): void {

src/services/rename.ts

@@ -13,7 +13,18 @@ namespace ts.Rename {
 
     function getRenameInfoForNode(node: Node, typeChecker: TypeChecker, sourceFile: SourceFile, isDefinedInLibraryFile: (declaration: Node) => boolean, options?: RenameInfoOptions): RenameInfo | undefined {
         const symbol = typeChecker.getSymbolAtLocation(node);
-        if (!symbol) return;
+        if (!symbol) {
+            if (isStringLiteralLike(node)) {
+                const type = getContextualTypeOrAtAncestorTypeNode(node, typeChecker);
+                if (type && ((type.flags & TypeFlags.StringLiteral) || (
+                    (type.flags & TypeFlags.Union) && every((type as UnionType).types, type => !!(type.flags & TypeFlags.StringLiteral))
+                ))) {
+                    return getRenameInfoSuccess(node.text, node.text, ScriptElementKind.string, "", node, sourceFile);
+                }
+            }
+            return;
+        };
+
         // Only allow a symbol to be renamed if it actually has at least one declaration.
         const { declarations } = symbol;
         if (!declarations || declarations.length === 0) return;

src/services/utilities.ts

@@ -771,6 +771,20 @@ namespace ts {
         }
     }
 
+    function getAncestorTypeNode(node: Node) {
+        return findAncestor(node, a => !isQualifiedName(a.parent) && !isTypeNode(a.parent) && !isTypeElement(a.parent));
+    }
+
+    export function getContextualTypeOrAtAncestorTypeNode(node: Expression, checker: TypeChecker) {
+        const contextualType = checker.getContextualType(node);
+        if (contextualType) {
+            return contextualType;
+        }
+
+        const ancestorTypeNode = getAncestorTypeNode(node);
+        return ancestorTypeNode && checker.getTypeAtLocation(ancestorTypeNode);
+    }
+
     function getAdjustedLocationForDeclaration(node: Node, forRename: boolean) {
         if (!forRename) {
             switch (node.kind) {

tests/cases/fourslash/renameStringLiteralOk.ts

@@ -0,0 +1,10 @@
+/// <reference path='fourslash.ts'/>
+
+//// interface Foo {
+////     f: '[|foo|]' | 'bar'
+//// }
+//// const d: 'foo' = 'foo'
+//// declare const f: Foo
+//// f.f = '[|foo|]'
+
+verify.rangesWithSameTextAreRenameLocations("foo");

tests/cases/fourslash/renameStringLiteralTypes.ts

@@ -11,4 +11,4 @@
 ////
 ////animate({ deltaX: 100, deltaY: 100, easing: "[|ease-in-out|]" });
 
-goTo.eachRange(() => { verify.renameInfoFailed(); });
+verify.rangesWithSameTextAreRenameLocations("ease-in-out");