feat(57028): Support inlining variables that are used in object literal shorthand (#57051)

Author: a-tarasyuk

src/services/refactors/inlineVariable.ts

@@ -23,6 +23,7 @@ import {
     isNumericLiteral,
     isObjectLiteralExpression,
     isPropertyAccessExpression,
+    isShorthandPropertyAssignment,
     isTypeQueryNode,
     isVariableDeclarationInVariableStatement,
     isVariableStatement,
@@ -102,7 +103,6 @@ registerRefactor(refactorName, {
 
     getEditsForAction(context, actionName) {
         Debug.assert(actionName === refactorName, "Unexpected refactor invoked");
-
         const { file, program, startPosition } = context;
 
         // tryWithReferenceToken is true below since here we're already performing the refactor.
@@ -189,9 +189,10 @@ function isDeclarationExported(declaration: InitializedVariableDeclaration): boo
 function getReferenceNodes(declaration: InitializedVariableDeclaration, checker: TypeChecker, file: SourceFile): Identifier[] | undefined {
     const references: Identifier[] = [];
     const cannotInline = FindAllReferences.Core.eachSymbolReferenceInFile(declaration.name as Identifier, checker, file, ref => {
-        // Only inline if all references are reads. Else we might end up with an invalid scenario like:
-        // const y = x++ + 1 -> const y = 2++ + 1
-        if (FindAllReferences.isWriteAccessForReference(ref)) {
+        // Only inline if all references are reads, or if it includes a shorthand property assignment.
+        // Else we might end up with an invalid scenario like:
+        // const y = x++ + 1 -> const y = 2++ + 1,
+        if (FindAllReferences.isWriteAccessForReference(ref) && !isShorthandPropertyAssignment(ref.parent)) {
             return true;
         }
 
@@ -216,7 +217,7 @@ function getReferenceNodes(declaration: InitializedVariableDeclaration, checker:
     return references.length === 0 || cannotInline ? undefined : references;
 }
 
-function getReplacementExpression(reference: Node, replacement: Expression): Expression {
+function getReplacementExpression(reference: Node, replacement: Expression) {
     // Make sure each reference site gets its own copy of the replacement node.
     replacement = getSynthesizedDeepClone(replacement);
     const { parent } = reference;
@@ -244,5 +245,13 @@ function getReplacementExpression(reference: Node, replacement: Expression): Exp
         return factory.createParenthesizedExpression(replacement);
     }
 
+    // Inline shorthand property assignment
+    // E.g.:
+    // const x = 1;
+    // const y = { x }; -> const y = { x: 1 };
+    if (isIdentifier(reference) && isShorthandPropertyAssignment(parent)) {
+        return factory.createPropertyAssignment(reference, replacement);
+    }
+
     return replacement;
 }

tests/cases/fourslash/inlineVariableShorthandPropertyAssignment.ts

@@ -0,0 +1,13 @@
+/// <reference path="fourslash.ts" />
+
+////const foo = 1;
+////const bar = { /*a*/foo/*b*/ };
+
+goTo.select("a", "b");
+edit.applyRefactor({
+    refactorName: "Inline variable",
+    actionName: "Inline variable",
+    actionDescription: "Inline variable",
+    newContent: "const bar = { foo: 1 };",
+    triggerReason: "invoked",
+});