Convert destruction

src/compiler/diagnosticMessages.json

@@ -7173,6 +7173,10 @@
         "category": "Message",
         "code": 95173
     },
+    "Convert access expression to destruction": {
+        "category": "Message",
+        "code": 95174
+    },
 
     "No value exists in scope for the shorthand property '{0}'. Either declare one or provide an initializer.": {
         "category": "Error",
@@ -7293,5 +7297,29 @@
     "A 'return' statement cannot be used inside a class static block.": {
         "category": "Error",
         "code": 18041
+    },
+    "No convertible access expression at location.": {
+        "category": "Error",
+        "code": 18042
+    },
+    "Cannot find convertible value declaration.": {
+        "category": "Error",
+        "code": 18043
+    },
+    "Cannot find convertible references.": {
+        "category": "Error",
+        "code": 18044
+    },
+    "Some references are un-convertible.": {
+        "category": "Error",
+        "code": 18045
+    },
+    "Too many empty array item.": {
+        "category": "Error",
+        "code": 18046
+    },
+    "At least '{0}' references are required.": {
+        "category": "Error",
+        "code": 18047
     }
 }

src/compiler/utilities.ts

@@ -3028,6 +3028,13 @@ namespace ts {
         return skipOuterExpressions(node, flags);
     }
 
+    export function skipParenthesesUp(node: Node): Node {
+        while (node.kind === SyntaxKind.ParenthesizedExpression) {
+            node = node.parent;
+        }
+        return node;
+    }
+
     // a node is delete target iff. it is PropertyAccessExpression/ElementAccessExpression with parentheses skipped
     export function isDeleteTarget(node: Node): boolean {
         if (node.kind !== SyntaxKind.PropertyAccessExpression && node.kind !== SyntaxKind.ElementAccessExpression) {

src/services/refactors/extractType.ts

@@ -133,10 +133,6 @@ namespace ts.refactor {
         return undefined;
     }
 
-    function rangeContainsSkipTrivia(r1: TextRange, node: Node, file: SourceFile): boolean {
-        return rangeContainsStartEnd(r1, skipTrivia(file.text, node.pos), node.end);
-    }
-
     function collectTypeParameters(checker: TypeChecker, selection: TypeNode, statement: Statement, file: SourceFile): TypeParameterDeclaration[] | undefined {
         const result: TypeParameterDeclaration[] = [];
         return visitor(selection) ? undefined : result;

src/services/refactors/helpers.ts

@@ -22,4 +22,33 @@ namespace ts.refactor {
         if(!requested) return true;
         return known.substr(0, requested.length) === requested;
     }
+
+    export const enum ResultStatus {
+        Ok,
+        Err
+    }
+
+    export interface OkResult<T> {
+        status: ResultStatus.Ok;
+        value: T;
+    }
+
+    export interface ErrResult {
+        status: ResultStatus.Err;
+        reason: string;
+    }
+
+    export type Result<T> = OkResult<T> | ErrResult;
+
+    export function isErrorResult<T>(result: Result<T>): result is ErrResult {
+        return result.status === ResultStatus.Err;
+    }
+
+    export function Err(reason: string): ErrResult {
+        return { status: ResultStatus.Err, reason };
+    }
+
+    export function Ok<T>(value: T): OkResult<T> {
+        return { status: ResultStatus.Ok, value };
+    }
 }

src/services/tsconfig.json

@@ -116,6 +116,7 @@
         "codefixes/fixAddVoidToPromise.ts",
         "refactors/convertExport.ts",
         "refactors/convertImport.ts",
+        "refactors/convertObjectDestruction.ts",
         "refactors/convertToOptionalChainExpression.ts",
         "refactors/convertOverloadListToSingleSignature.ts",
         "refactors/extractSymbol.ts",

src/services/utilities.ts

@@ -532,6 +532,13 @@ namespace ts {
         return start < end;
     }
 
+    /**
+     * @internal
+     */
+    export function rangeContainsSkipTrivia(r1: TextRange, node: Node, file: SourceFile): boolean {
+        return rangeContainsStartEnd(r1, skipTrivia(file.text, node.pos), node.end);
+    }
+
     /**
      * Assumes `candidate.start <= position` holds.
      */

tests/cases/fourslash/refactorIntroduceDestruction1.ts

@@ -0,0 +1,18 @@
+/// <reference path='fourslash.ts' />
+
+//// const item = {
+////     a: 1, b: 2
+//// }
+//// call(/*a*/item/*b*/.a, item.b)
+
+goTo.select("a", "b");
+edit.applyRefactor({
+    refactorName: "Convert to destruction",
+    actionName: "Convert to destruction",
+    actionDescription: ts.Diagnostics.Convert_access_expression_to_destruction.message,
+    newContent: `const item = {
+    a: 1, b: 2
+}
+const { a, b } = item
+call(a, b)`,
+});

tests/cases/fourslash/refactorIntroduceDestruction10.ts

@@ -0,0 +1,16 @@
+/// <reference path='fourslash.ts' />
+
+//// function foo (item: { a: string, b: number }) {
+////     call(/*a*/item/*b*/.a, item.b)
+//// }
+
+goTo.select("a", "b");
+edit.applyRefactor({
+    refactorName: "Convert to destruction",
+    actionName: "Convert to destruction",
+    actionDescription: ts.Diagnostics.Convert_access_expression_to_destruction.message,
+    newContent: `function foo (item: { a: string, b: number }) {
+    const { a, b } = item;
+    call(a, b)
+}`,
+});

tests/cases/fourslash/refactorIntroduceDestruction11.ts

@@ -0,0 +1,18 @@
+/// <reference path='fourslash.ts' />
+
+//// const item = {
+////     a: 1, b: 2
+//// }
+//// call(/*a*/item/*b*/["a"], item.b)
+
+goTo.select("a", "b");
+edit.applyRefactor({
+    refactorName: "Convert to destruction",
+    actionName: "Convert to destruction",
+    actionDescription: ts.Diagnostics.Convert_access_expression_to_destruction.message,
+    newContent: `const item = {
+    a: 1, b: 2
+}
+const { a, b } = item
+call(a, b)`,
+});

tests/cases/fourslash/refactorIntroduceDestruction12.ts

@@ -0,0 +1,10 @@
+/// <reference path='fourslash.ts' />
+
+//// const item = {
+////     a: 1, b: 2
+//// }
+//// const key = "a"
+//// call(/*a*/item/*b*/[key], item.b)
+
+goTo.select("a", "b");
+verify.not.refactorAvailable("Convert to destruction")

tests/cases/fourslash/refactorIntroduceDestruction13.ts

@@ -0,0 +1,20 @@
+/// <reference path='fourslash.ts' />
+
+//// const item = {
+////     a: 1, b: 2
+//// }
+//// const a = false
+//// call(/*a*/item/*b*/.a, item.b)
+
+goTo.select("a", "b");
+edit.applyRefactor({
+    refactorName: "Convert to destruction",
+    actionName: "Convert to destruction",
+    actionDescription: ts.Diagnostics.Convert_access_expression_to_destruction.message,
+    newContent: `const item = {
+    a: 1, b: 2
+}
+const a = false
+const { a: a_1, b } = item
+call(a_1, b)`,
+});

tests/cases/fourslash/refactorIntroduceDestruction14.ts

@@ -0,0 +1,28 @@
+/// <reference path='fourslash.ts' />
+
+//// const item = {
+////     a: 1, b: {
+////         c: {
+////             d: 1,
+////             e: 2
+////         }   
+////     }
+//// }
+//// call(/*a*/item/*b*/.a, item.b, item.b.c, item.b.c.d, item.b.c.e)
+
+goTo.select("a", "b");
+edit.applyRefactor({
+    refactorName: "Convert to destruction",
+    actionName: "Convert to destruction",
+    actionDescription: ts.Diagnostics.Convert_access_expression_to_destruction.message,
+    newContent: `const item = {
+    a: 1, b: {
+        c: {
+            d: 1,
+            e: 2
+        }   
+    }
+}
+const { a, b } = item
+call(a, b, b.c, b.c.d, b.c.e)`,
+});

tests/cases/fourslash/refactorIntroduceDestruction15.ts

@@ -0,0 +1,29 @@
+/// <reference path='fourslash.ts' />
+
+//// const item = {
+////     a: 1, b: {
+////         c: {
+////             d: 1,
+////             e: 2
+////         }   
+////     }
+//// }
+//// call(item.a, item.b, /*a*/item.b/*b*/.c, item.b.c.d, item.b.c.e)
+
+goTo.select("a", "b");
+edit.applyRefactor({
+    refactorName: "Convert to destruction",
+    actionName: "Convert to destruction",
+    actionDescription: ts.Diagnostics.Convert_access_expression_to_destruction.message,
+    newContent: `const item = {
+    a: 1, b: {
+        c: {
+            d: 1,
+            e: 2
+        }   
+    }
+}
+const { c } = item.b
+call(item.a, item.b, c, c.d, c.e)`,
+});
+

tests/cases/fourslash/refactorIntroduceDestruction16.ts

@@ -0,0 +1,28 @@
+/// <reference path='fourslash.ts' />
+
+//// const item = {
+////     a: 1, b: {
+////         c: {
+////             d: 1,
+////             e: 2
+////         }   
+////     }
+//// }
+//// call(item.a, item.b, item.b.c, /*a*/item.b.c/*b*/.d, item.b.c.e)
+
+goTo.select("a", "b");
+edit.applyRefactor({
+    refactorName: "Convert to destruction",
+    actionName: "Convert to destruction",
+    actionDescription: ts.Diagnostics.Convert_access_expression_to_destruction.message,
+    newContent: `const item = {
+    a: 1, b: {
+        c: {
+            d: 1,
+            e: 2
+        }   
+    }
+}
+const { d, e } = item.b.c
+call(item.a, item.b, item.b.c, d, e)`,
+});

tests/cases/fourslash/refactorIntroduceDestruction17.ts

@@ -0,0 +1,23 @@
+/// <reference path='fourslash.ts' />
+
+//// interface A {
+////     f: 1,
+////     b: number
+////     c: () => void
+//// }
+//// interface B {
+////     f: 2,
+////     b: number
+////     c: () => string
+//// }
+//// declare const a: A | B
+//// if (/*a*/a/*b*/.f === 1) {
+////     a.b = 1
+////     a.c()
+//// } else {
+////     a.b = 2
+////     a.c()
+//// }
+
+goTo.select("a", "b");
+verify.not.refactorAvailable("Convert to destruction")

tests/cases/fourslash/refactorIntroduceDestruction18.ts

@@ -0,0 +1,43 @@
+/// <reference path='fourslash.ts' />
+
+//// interface A {
+////     f: 1,
+////     b: number
+////     c: () => void
+//// }
+//// interface B {
+////     f: 2,
+////     b: number
+////     c: () => string
+//// }
+//// declare const a: A | B
+//// if (/*a*/a/*b*/.f === 1) {
+////     a.b = 1
+//// } else {
+////     a.b = 2
+//// }
+
+goTo.select("a", "b");
+edit.applyRefactor({
+    refactorName: "Convert to destruction",
+    actionName: "Convert to destruction",
+    triggerReason: "invoked",
+    actionDescription: ts.Diagnostics.Convert_access_expression_to_destruction.message,
+    newContent: `interface A {
+    f: 1,
+    b: number
+    c: () => void
+}
+interface B {
+    f: 2,
+    b: number
+    c: () => string
+}
+declare const a: A | B
+const { f } = a
+if (f === 1) {
+    a.b = 1
+} else {
+    a.b = 2
+}`,
+});

tests/cases/fourslash/refactorIntroduceDestruction19.ts

@@ -0,0 +1,9 @@
+/// <reference path='fourslash.ts' />
+
+//// const item = {
+////     "a-a-a": 1, b: 2
+//// }
+//// call(/*a*/item/*b*/["a-a-a"], item.b)
+
+goTo.select("a", "b");
+verify.not.refactorAvailable("Convert to destruction")

tests/cases/fourslash/refactorIntroduceDestruction2.ts

@@ -0,0 +1,18 @@
+/// <reference path='fourslash.ts' />
+
+//// const item = {
+////     a: 1, b: 2
+//// }
+//// call(item.a, /*a*/item/*b*/.b)
+
+goTo.select("a", "b");
+edit.applyRefactor({
+    refactorName: "Convert to destruction",
+    actionName: "Convert to destruction",
+    actionDescription: ts.Diagnostics.Convert_access_expression_to_destruction.message,
+    newContent: `const item = {
+    a: 1, b: 2
+}
+const { a, b } = item
+call(a, b)`,
+});