add refactoring: inline local variable

src/compiler/diagnosticMessages.json

@@ -4799,5 +4799,17 @@
     "Add names to all parameters without names": {
         "category": "Message",
         "code": 95073
+    },
+    "Inline local": {
+        "category": "Message",
+        "code": 95080
+    },
+    "Inline here": {
+        "category": "Message",
+        "code": 95081
+    },
+    "Inline all": {
+        "category": "Message",
+        "code": 95082
     }
 }

src/services/refactors/inlineLocal.ts

@@ -0,0 +1,182 @@
+/* @internal */
+namespace ts.refactor.inlineLocal {
+    const refactorName = "Inline local";
+    const refactorDescription = getLocaleSpecificMessage(Diagnostics.Inline_local);
+
+    const inlineHereActionName = "Inline here";
+    const inlineAllActionName = "Inline all";
+
+    const inlineHereActionDescription = getLocaleSpecificMessage(Diagnostics.Inline_here);
+    const inlineAllActionDescription = getLocaleSpecificMessage(Diagnostics.Inline_all);
+
+
+    registerRefactor(refactorName, { getEditsForAction, getAvailableActions });
+
+    interface Info {
+        readonly declaration: VariableDeclaration;
+        readonly usages: ReadonlyArray<Identifier>;
+        readonly selectedUsage: Identifier | undefined;
+    }
+
+    function getAvailableActions(context: RefactorContext): ReadonlyArray<ApplicableRefactorInfo> {
+        const { file, program, startPosition } = context;
+        const info = getLocalInfo(file, program, startPosition);
+        if (!info) return emptyArray;
+        const { selectedUsage } = info;
+        const refactorInfo = {
+            name: refactorName,
+            description: refactorDescription,
+            actions: [{
+                name: inlineAllActionName,
+                description: inlineAllActionDescription
+            }]
+        };
+        if (selectedUsage) {
+            refactorInfo.actions.push({
+                name: inlineHereActionName,
+                description: inlineHereActionDescription
+            });
+        }
+        return [refactorInfo];
+    }
+
+    function getLocalInfo(file: SourceFile, program: Program, startPosition: number): Info | undefined {
+        const token = getTokenAtPosition(file, startPosition);
+        const maybeDeclaration = token.parent;
+        const checker = program.getTypeChecker();
+        if (isLocalVariable(maybeDeclaration)) {
+            return createInfo(checker, maybeDeclaration);
+        }
+        if (isIdentifier(token)) {
+            const symbol = checker.getSymbolAtLocation(token);
+            if (!symbol) return undefined;
+            const declaration = symbol.valueDeclaration;
+            if (!isLocalVariable(declaration)) return undefined;
+            return createInfo(checker, declaration, token);
+        }
+        return undefined;
+    }
+
+    function isLocalVariable(parent: Node): parent is VariableDeclaration {
+        return isVariableDeclaration(parent) && isVariableDeclarationInVariableStatement(parent);
+    }
+
+    function createInfo(checker: TypeChecker, declaration: VariableDeclaration, token?: Identifier): Info | undefined {
+        const name = declaration.name;
+        const usages = getReferencesInScope(getEnclosingBlockScopeContainer(name), name, checker, /* withDeclaration */ false);
+        return canInline(declaration, usages) ? {
+            declaration,
+            usages,
+            selectedUsage: token ? token : undefined
+        } : undefined;
+    }
+
+    function canInline(declaration: VariableDeclaration, usages: ReadonlyArray<Identifier>): boolean {
+        let hasErrors = false;
+        if (!declaration.initializer) hasErrors = true;
+        if (containsProhibitedModifiers(declaration.parent.parent.modifiers)) hasErrors = true;
+        forEach(usages, usage => {
+            if (isAssigned(usage)) hasErrors = true;
+        });
+        return !hasErrors;
+    }
+
+    function isAssigned(usage: Identifier): boolean {
+        type AssignExpr = AssignmentExpression<AssignmentOperatorToken>;
+        const assignment: AssignExpr = findAncestor(
+            usage,
+            ancestor => isAssignmentExpression(ancestor)) as AssignExpr;
+        return assignment && assignment.left === usage;
+    }
+
+    function containsProhibitedModifiers(modifiers?: NodeArray<Modifier>): boolean {
+        return !!modifiers && !!modifiers.find(mod => mod.kind === SyntaxKind.ExportKeyword);
+    }
+
+    function getEditsForAction(context: RefactorContext, actionName: string): RefactorEditInfo | undefined {
+        const { file, program, startPosition } = context;
+        const info = getLocalInfo(file, program, startPosition);
+        if (!info) return undefined;
+        const { declaration, usages, selectedUsage } = info;
+        switch (actionName) {
+            case inlineAllActionName:
+                return { edits: getInlineAllEdits(context, declaration, usages) };
+            case inlineHereActionName:
+                return { edits: getInlineHereEdits(context, declaration, usages, selectedUsage!) };
+            default:
+                return Debug.fail("invalid action");
+        }
+    }
+
+    function getInlineAllEdits(
+        context: RefactorContext,
+        declaration: VariableDeclaration,
+        usages: ReadonlyArray<Identifier>): FileTextChanges[] {
+        const { file } = context;
+        return textChanges.ChangeTracker.with(context, t => {
+            forEach(usages, oldNode => {
+                const { initializer } = declaration;
+                makeIdUnique(initializer!); // since there is no node-copying function
+                const expression = parenthesizeIfNecessary(oldNode, initializer!);
+                t.replaceNode(file, oldNode, expression);
+            });
+            t.delete(file, declaration);
+        });
+    }
+
+    function getInlineHereEdits(context: RefactorContext,
+        declaration: VariableDeclaration,
+        usages: ReadonlyArray<Identifier>,
+        selectedUsage: Identifier): FileTextChanges[] {
+        const { file } = context;
+        return textChanges.ChangeTracker.with(context, t => {
+            const { initializer } = declaration;
+            const expression = parenthesizeIfNecessary(selectedUsage, initializer!);
+            t.replaceNode(file, selectedUsage, expression);
+            if (usages.length === 1) t.delete(file, declaration);
+        });
+    }
+
+    function makeIdUnique(node: Node): void {
+        node.id = undefined;
+        getNodeId(node);
+    }
+
+    function parenthesizeIfNecessary(target: Node, expression: Expression): Expression {
+        const parent = target.parent;
+        if (isBinaryExpression(parent)) {
+            return parenthesizeBinaryOperand(
+                parent.operatorToken.kind,
+                expression,
+                target === parent.left,
+                parent.left);
+        }
+        if (isExpression(parent)) {
+            const parentPrecedence = getExpressionPrecedence(parent);
+            const expressionPrecedence = getExpressionPrecedence(expression);
+            if (parentPrecedence > expressionPrecedence) return createParen(expression);
+            else return expression;
+        }
+        return expression;
+    }
+
+    function getReferencesInScope(scope: Node, target: Node, checker: TypeChecker, withDeclaration: boolean): ReadonlyArray<Identifier> {
+        const symbol = checker.getSymbolAtLocation(target);
+        return findDescendants(scope, n =>
+            checker.getSymbolAtLocation(n) === symbol &&
+            (withDeclaration || !isDeclaration(n.parent))) as Identifier[];
+    }
+
+    function findDescendants(node: Node, predicate: (n: Node) => boolean) {
+        const nodes: Node[] = [];
+        visitDescendants(node);
+
+        function visitDescendants(node: Node) {
+            forEachChild(node, n => {
+                if (predicate(n)) nodes.push(n);
+                visitDescendants(n);
+            });
+        }
+        return nodes;
+    }
+}

src/services/tsconfig.json

@@ -80,6 +80,7 @@
         "refactors/convertExport.ts",
         "refactors/convertImport.ts",
         "refactors/extractSymbol.ts",
+        "refactors/inlineLocal.ts",
         "refactors/generateGetAccessorAndSetAccessor.ts",
         "refactors/moveToNewFile.ts",
         "refactors/addOrRemoveBracesToArrowFunction.ts",

tests/cases/fourslash/refactorInlineLocal_Availability_Export.ts

@@ -0,0 +1,12 @@
+/// <reference path='fourslash.ts' />
+
+//// export const /*z*/a/*y*/ = 42-3;
+//// const b = 2 * /*x*/a/*w*/;
+
+goTo.select("z", "y");
+verify.not.refactorAvailable("Inline local", "Inline all");
+verify.not.refactorAvailable("Inline local", "Inline here");
+
+goTo.select("x", "w");
+verify.not.refactorAvailable("Inline local", "Inline all");
+verify.not.refactorAvailable("Inline local", "Inline here");

tests/cases/fourslash/refactorInlineLocal_Availability_MultiAssign.ts

@@ -0,0 +1,13 @@
+/// <reference path='fourslash.ts' />
+
+//// let /*z*/a/*y*/ = 42-3;
+//// a = 23;
+//// const b = 2 * /*x*/a/*w*/;
+
+goTo.select("z", "y");
+verify.not.refactorAvailable("Inline local", "Inline all");
+verify.not.refactorAvailable("Inline local", "Inline here");
+
+goTo.select("x", "w");
+verify.not.refactorAvailable("Inline local", "Inline all");
+verify.not.refactorAvailable("Inline local", "Inline here");

tests/cases/fourslash/refactorInlineLocal_Availability_Simple.ts

@@ -0,0 +1,12 @@
+/// <reference path='fourslash.ts' />
+
+//// const /*z*/a/*y*/ = 42-3;
+//// const b = 2 * /*x*/a/*w*/;
+
+goTo.select("z", "y");
+verify.refactorAvailable("Inline local", "Inline all");
+verify.not.refactorAvailable("Inline local", "Inline here");
+
+goTo.select("x", "w");
+verify.refactorAvailable("Inline local", "Inline all");
+verify.refactorAvailable("Inline local", "Inline here");

tests/cases/fourslash/refactorInlineLocal_Availability_Uninitialized.ts

@@ -0,0 +1,13 @@
+/// <reference path='fourslash.ts' />
+
+//// let /*z*/a/*y*/;
+//// const b = 2 * /*x*/a/*w*/;
+
+
+goTo.select("z", "y");
+verify.not.refactorAvailable("Inline local", "Inline all");
+verify.not.refactorAvailable("Inline local", "Inline here");
+
+goTo.select("x", "w");
+verify.not.refactorAvailable("Inline local", "Inline all");
+verify.not.refactorAvailable("Inline local", "Inline here");

tests/cases/fourslash/refactorInlineLocal_FunctionCall_NoUnnecessaryParentheses.ts

@@ -0,0 +1,14 @@
+/// <reference path='fourslash.ts' />
+
+//// const /*z*/a/*y*/ = 42;
+//// function b (arg: number) { return arg; }
+//// b(a);
+
+goTo.select("z", "y");
+edit.applyRefactor({
+    refactorName: "Inline local",
+    actionName: "Inline all",
+    actionDescription: "Inline all",
+    newContent: `function b (arg: number) { return arg; }
+b(42);`
+});

tests/cases/fourslash/refactorInlineLocal_MultiUse_Declaration.ts

@@ -0,0 +1,14 @@
+/// <reference path='fourslash.ts' />
+
+//// const /*z*/a/*y*/ = 42 - 3;
+//// const b = 2 * /*x*/a/*w*/;
+//// const c = 2 + a;
+
+goTo.select("z", "y");
+edit.applyRefactor({
+    refactorName: "Inline local",
+    actionName: "Inline all",
+    actionDescription: "Inline all",
+    newContent: `const b = 2 * (42 - 3);
+const c = 2 + (42 - 3);`
+});

tests/cases/fourslash/refactorInlineLocal_MultiUse_Usage_InlineAll.ts

@@ -0,0 +1,14 @@
+/// <reference path='fourslash.ts' />
+
+//// const /*z*/a/*y*/ = 42 - 3;
+//// const b = 2 * /*x*/a/*w*/;
+//// const c = 2 + a;
+
+goTo.select("x", "w");
+edit.applyRefactor({
+    refactorName: "Inline local",
+    actionName: "Inline all",
+    actionDescription: "Inline all",
+    newContent: `const b = 2 * (42 - 3);
+const c = 2 + (42 - 3);`
+});

tests/cases/fourslash/refactorInlineLocal_MultiUse_Usage_InlineHere.ts

@@ -0,0 +1,15 @@
+/// <reference path='fourslash.ts' />
+
+//// const /*z*/a/*y*/ = 42 - 3;
+//// const b = 2 * /*x*/a/*w*/;
+//// const c = 2 + a;
+
+goTo.select("x", "w");
+edit.applyRefactor({
+    refactorName: "Inline local",
+    actionName: "Inline here",
+    actionDescription: "Inline here",
+    newContent: `const a = 42 - 3;
+const b = 2 * (42 - 3);
+const c = 2 + a;`
+});

tests/cases/fourslash/refactorInlineLocal_Precedence_Binary_Left_1.ts

@@ -0,0 +1,12 @@
+/// <reference path='fourslash.ts' />
+
+//// const /*z*/a/*y*/ = 42 + 3;
+//// const b = /*x*/a/*w*/ + 2;
+
+goTo.select("z", "y");
+edit.applyRefactor({
+    refactorName: "Inline local",
+    actionName: "Inline all",
+    actionDescription: "Inline all",
+    newContent: `const b = 42 + 3 + 2;`
+});

tests/cases/fourslash/refactorInlineLocal_Precedence_Binary_Left_2.ts

@@ -0,0 +1,12 @@
+/// <reference path='fourslash.ts' />
+
+//// const /*z*/a/*y*/ = 42 + 3;
+//// const b = /*x*/a/*w*/ * 2;
+
+goTo.select("z", "y");
+edit.applyRefactor({
+    refactorName: "Inline local",
+    actionName: "Inline all",
+    actionDescription: "Inline all",
+    newContent: `const b = (42 + 3) * 2;`
+});

tests/cases/fourslash/refactorInlineLocal_Precedence_Binary_Left_3.ts

@@ -0,0 +1,12 @@
+/// <reference path='fourslash.ts' />
+
+//// const /*z*/a/*y*/ = 42 + 3;
+//// const b = /*x*/a/*w*/ - 2;
+
+goTo.select("z", "y");
+edit.applyRefactor({
+    refactorName: "Inline local",
+    actionName: "Inline all",
+    actionDescription: "Inline all",
+    newContent: `const b = 42 + 3 - 2;`
+});

tests/cases/fourslash/refactorInlineLocal_Precedence_Binary_Left_4.ts

@@ -0,0 +1,12 @@
+/// <reference path='fourslash.ts' />
+
+//// const /*z*/a/*y*/ = 42 == 3;
+//// const b = /*x*/a/*w*/ != false;
+
+goTo.select("z", "y");
+edit.applyRefactor({
+    refactorName: "Inline local",
+    actionName: "Inline all",
+    actionDescription: "Inline all",
+    newContent: `const b = 42 == 3 != false;`
+});

tests/cases/fourslash/refactorInlineLocal_Precedence_Binary_Left_5.ts

@@ -0,0 +1,12 @@
+/// <reference path='fourslash.ts' />
+
+//// const /*z*/a/*y*/ = 42 * 3;
+//// const b = /*x*/a/*w*/ * 2;
+
+goTo.select("z", "y");
+edit.applyRefactor({
+    refactorName: "Inline local",
+    actionName: "Inline all",
+    actionDescription: "Inline all",
+    newContent: `const b = 42 * 3 * 2;`
+});