[Release 2.0] fix10076 : Destructing with "this" (#10209)

* Call checkExpression eventhough there is no appropriate type from destructuring of array

* Add tests and baselines

Author: yuit

src/compiler/checker.ts

@@ -4308,9 +4308,14 @@ namespace ts {
             return property;
         }
 
-        // Return the symbol for the property with the given name in the given type. Creates synthetic union properties when
-        // necessary, maps primitive types and type parameters are to their apparent types, and augments with properties from
-        // Object and Function as appropriate.
+        /**
+         * Return the symbol for the property with the given name in the given type. Creates synthetic union properties when
+         * necessary, maps primitive types and type parameters are to their apparent types, and augments with properties from
+         * Object and Function as appropriate.
+         *
+         * @param type a type to look up property from
+         * @param name a name of property to look up in a given type
+         */
         function getPropertyOfType(type: Type, name: string): Symbol {
             type = getApparentType(type);
             if (type.flags & TypeFlags.ObjectType) {
@@ -12516,6 +12521,9 @@ namespace ts {
                         return checkDestructuringAssignment(element, type, contextualMapper);
                     }
                     else {
+                        // We still need to check element expression here because we may need to set appropriate flag on the expression
+                        // such as NodeCheckFlags.LexicalThis on "this"expression.
+                        checkExpression(element);
                         if (isTupleType(sourceType)) {
                             error(element, Diagnostics.Tuple_type_0_with_length_1_cannot_be_assigned_to_tuple_with_length_2, typeToString(sourceType), (<TupleType>sourceType).elementTypes.length, elements.length);
                         }

tests/baselines/reference/emitCapturingThisInTupleDestructuring1.errors.txt

@@ -0,0 +1,13 @@
+tests/cases/compiler/emitCapturingThisInTupleDestructuring1.ts(3,17): error TS2493: Tuple type '[any]' with length '1' cannot be assigned to tuple with length '3'.
+tests/cases/compiler/emitCapturingThisInTupleDestructuring1.ts(3,29): error TS2493: Tuple type '[any]' with length '1' cannot be assigned to tuple with length '3'.
+
+
+==== tests/cases/compiler/emitCapturingThisInTupleDestructuring1.ts (2 errors) ====
+    declare function wrapper(x: any);
+    wrapper((array: [any]) => {
+        [this.test, this.test1, this.test2] = array;  // even though there is a compiler error, we should still emit lexical capture for "this"
+                    ~~~~~~~~~~
+!!! error TS2493: Tuple type '[any]' with length '1' cannot be assigned to tuple with length '3'.
+                                ~~~~~~~~~~
+!!! error TS2493: Tuple type '[any]' with length '1' cannot be assigned to tuple with length '3'.
+    });

tests/baselines/reference/emitCapturingThisInTupleDestructuring1.js

@@ -0,0 +1,11 @@
+//// [emitCapturingThisInTupleDestructuring1.ts]
+declare function wrapper(x: any);
+wrapper((array: [any]) => {
+    [this.test, this.test1, this.test2] = array;  // even though there is a compiler error, we should still emit lexical capture for "this"
+});
+
+//// [emitCapturingThisInTupleDestructuring1.js]
+var _this = this;
+wrapper(function (array) {
+    _this.test = array[0], _this.test1 = array[1], _this.test2 = array[2]; // even though there is a compiler error, we should still emit lexical capture for "this"
+});

tests/baselines/reference/emitCapturingThisInTupleDestructuring2.errors.txt

@@ -0,0 +1,16 @@
+tests/cases/compiler/emitCapturingThisInTupleDestructuring2.ts(8,39): error TS2493: Tuple type '[number, number]' with length '2' cannot be assigned to tuple with length '3'.
+
+
+==== tests/cases/compiler/emitCapturingThisInTupleDestructuring2.ts (1 errors) ====
+    var array1: [number, number] = [1, 2];
+    
+    class B {
+        test: number;
+        test1: any;
+        test2: any;
+        method() {
+            () => [this.test, this.test1, this.test2] = array1; // even though there is a compiler error, we should still emit lexical capture for "this" 
+                                          ~~~~~~~~~~
+!!! error TS2493: Tuple type '[number, number]' with length '2' cannot be assigned to tuple with length '3'.
+        }
+    }

tests/baselines/reference/emitCapturingThisInTupleDestructuring2.js

@@ -0,0 +1,23 @@
+//// [emitCapturingThisInTupleDestructuring2.ts]
+var array1: [number, number] = [1, 2];
+
+class B {
+    test: number;
+    test1: any;
+    test2: any;
+    method() {
+        () => [this.test, this.test1, this.test2] = array1; // even though there is a compiler error, we should still emit lexical capture for "this" 
+    }
+}
+
+//// [emitCapturingThisInTupleDestructuring2.js]
+var array1 = [1, 2];
+var B = (function () {
+    function B() {
+    }
+    B.prototype.method = function () {
+        var _this = this;
+        (function () { return (_this.test = array1[0], _this.test1 = array1[1], _this.test2 = array1[2], array1); }); // even though there is a compiler error, we should still emit lexical capture for "this" 
+    };
+    return B;
+}());

tests/cases/compiler/emitCapturingThisInTupleDestructuring1.ts

@@ -0,0 +1,4 @@
+declare function wrapper(x: any);
+wrapper((array: [any]) => {
+    [this.test, this.test1, this.test2] = array;  // even though there is a compiler error, we should still emit lexical capture for "this"
+});

tests/cases/compiler/emitCapturingThisInTupleDestructuring2.ts

@@ -0,0 +1,10 @@
+var array1: [number, number] = [1, 2];
+
+class B {
+    test: number;
+    test1: any;
+    test2: any;
+    method() {
+        () => [this.test, this.test1, this.test2] = array1; // even though there is a compiler error, we should still emit lexical capture for "this" 
+    }
+}