Report a semantic error for an arrow function with a "this" parameter.

Fixes microsoft#9744.

Author: mattmccutchen

src/compiler/checker.ts

@@ -21857,6 +21857,9 @@ namespace ts {
                 if (func.kind === SyntaxKind.Constructor || func.kind === SyntaxKind.ConstructSignature || func.kind === SyntaxKind.ConstructorType) {
                     error(node, Diagnostics.A_constructor_cannot_have_a_this_parameter);
                 }
+                if (func.kind === SyntaxKind.ArrowFunction) {
+                    error(node, Diagnostics.An_arrow_function_cannot_have_a_this_parameter);
+                }
             }
 
             // Only check rest parameter type if it's not a binding pattern. Since binding patterns are

src/compiler/diagnosticMessages.json

@@ -2417,6 +2417,10 @@
         "category": "Error",
         "code": 2729
     },
+    "An arrow function cannot have a 'this' parameter.": {
+        "category": "Error",
+        "code": 2730
+    },
 
     "Import declaration '{0}' is using private name '{1}'.": {
         "category": "Error",

src/compiler/parser.ts

@@ -3537,8 +3537,9 @@ namespace ts {
                 }
 
                 // If we had "(" followed by something that's not an identifier,
-                // then this definitely doesn't look like a lambda.
-                if (!isIdentifier()) {
+                // then this definitely doesn't look like a lambda.  "this" is not
+                // valid, but we want to parse it and then give a semantic error.
+                if (!isIdentifier() && second !== SyntaxKind.ThisKeyword) {
                     return Tristate.False;
                 }
 

tests/baselines/reference/arrowFunctionWithThisParameter.errors.txt

@@ -0,0 +1,43 @@
+tests/cases/compiler/arrowFunctionWithThisParameter.ts(2,15): error TS2730: An arrow function cannot have a 'this' parameter.
+tests/cases/compiler/arrowFunctionWithThisParameter.ts(4,20): error TS2331: 'this' cannot be referenced in a module or namespace body.
+tests/cases/compiler/arrowFunctionWithThisParameter.ts(6,18): error TS2730: An arrow function cannot have a 'this' parameter.
+tests/cases/compiler/arrowFunctionWithThisParameter.ts(7,20): error TS2331: 'this' cannot be referenced in a module or namespace body.
+tests/cases/compiler/arrowFunctionWithThisParameter.ts(9,21): error TS2730: An arrow function cannot have a 'this' parameter.
+tests/cases/compiler/arrowFunctionWithThisParameter.ts(10,20): error TS2331: 'this' cannot be referenced in a module or namespace body.
+tests/cases/compiler/arrowFunctionWithThisParameter.ts(12,24): error TS2730: An arrow function cannot have a 'this' parameter.
+tests/cases/compiler/arrowFunctionWithThisParameter.ts(13,20): error TS2331: 'this' cannot be referenced in a module or namespace body.
+
+
+==== tests/cases/compiler/arrowFunctionWithThisParameter.ts (8 errors) ====
+    namespace CannotReferenceThisInHere {
+        let f1 = (this: number) => {
+                  ~~~~~~~~~~~~
+!!! error TS2730: An arrow function cannot have a 'this' parameter.
+            // Test that the erroneously specified "this" type is not being used.
+            let that = this;
+                       ~~~~
+!!! error TS2331: 'this' cannot be referenced in a module or namespace body.
+        };
+        let f2 = <T>(this: number) => {
+                     ~~~~~~~~~~~~
+!!! error TS2730: An arrow function cannot have a 'this' parameter.
+            let that = this;
+                       ~~~~
+!!! error TS2331: 'this' cannot be referenced in a module or namespace body.
+        };
+        let f3 = async (this: number) => {
+                        ~~~~~~~~~~~~
+!!! error TS2730: An arrow function cannot have a 'this' parameter.
+            let that = this;
+                       ~~~~
+!!! error TS2331: 'this' cannot be referenced in a module or namespace body.
+        };
+        let f4 = async <T>(this: number) => {
+                           ~~~~~~~~~~~~
+!!! error TS2730: An arrow function cannot have a 'this' parameter.
+            let that = this;
+                       ~~~~
+!!! error TS2331: 'this' cannot be referenced in a module or namespace body.
+        };
+    }
+    

tests/baselines/reference/arrowFunctionWithThisParameter.js

@@ -0,0 +1,43 @@
+//// [arrowFunctionWithThisParameter.ts]
+namespace CannotReferenceThisInHere {
+    let f1 = (this: number) => {
+        // Test that the erroneously specified "this" type is not being used.
+        let that = this;
+    };
+    let f2 = <T>(this: number) => {
+        let that = this;
+    };
+    let f3 = async (this: number) => {
+        let that = this;
+    };
+    let f4 = async <T>(this: number) => {
+        let that = this;
+    };
+}
+
+
+//// [arrowFunctionWithThisParameter.js]
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var CannotReferenceThisInHere;
+(function (CannotReferenceThisInHere) {
+    let f1 = () => {
+        // Test that the erroneously specified "this" type is not being used.
+        let that = this;
+    };
+    let f2 = () => {
+        let that = this;
+    };
+    let f3 = () => __awaiter(this, void 0, void 0, function* () {
+        let that = this;
+    });
+    let f4 = () => __awaiter(this, void 0, void 0, function* () {
+        let that = this;
+    });
+})(CannotReferenceThisInHere || (CannotReferenceThisInHere = {}));

tests/baselines/reference/arrowFunctionWithThisParameter.symbols

@@ -0,0 +1,41 @@
+=== tests/cases/compiler/arrowFunctionWithThisParameter.ts ===
+namespace CannotReferenceThisInHere {
+>CannotReferenceThisInHere : Symbol(CannotReferenceThisInHere, Decl(arrowFunctionWithThisParameter.ts, 0, 0))
+
+    let f1 = (this: number) => {
+>f1 : Symbol(f1, Decl(arrowFunctionWithThisParameter.ts, 1, 7))
+>this : Symbol(this, Decl(arrowFunctionWithThisParameter.ts, 1, 14))
+
+        // Test that the erroneously specified "this" type is not being used.
+        let that = this;
+>that : Symbol(that, Decl(arrowFunctionWithThisParameter.ts, 3, 11))
+
+    };
+    let f2 = <T>(this: number) => {
+>f2 : Symbol(f2, Decl(arrowFunctionWithThisParameter.ts, 5, 7))
+>T : Symbol(T, Decl(arrowFunctionWithThisParameter.ts, 5, 14))
+>this : Symbol(this, Decl(arrowFunctionWithThisParameter.ts, 5, 17))
+
+        let that = this;
+>that : Symbol(that, Decl(arrowFunctionWithThisParameter.ts, 6, 11))
+
+    };
+    let f3 = async (this: number) => {
+>f3 : Symbol(f3, Decl(arrowFunctionWithThisParameter.ts, 8, 7))
+>this : Symbol(this, Decl(arrowFunctionWithThisParameter.ts, 8, 20))
+
+        let that = this;
+>that : Symbol(that, Decl(arrowFunctionWithThisParameter.ts, 9, 11))
+
+    };
+    let f4 = async <T>(this: number) => {
+>f4 : Symbol(f4, Decl(arrowFunctionWithThisParameter.ts, 11, 7))
+>T : Symbol(T, Decl(arrowFunctionWithThisParameter.ts, 11, 20))
+>this : Symbol(this, Decl(arrowFunctionWithThisParameter.ts, 11, 23))
+
+        let that = this;
+>that : Symbol(that, Decl(arrowFunctionWithThisParameter.ts, 12, 11))
+
+    };
+}
+

tests/baselines/reference/arrowFunctionWithThisParameter.types

@@ -0,0 +1,49 @@
+=== tests/cases/compiler/arrowFunctionWithThisParameter.ts ===
+namespace CannotReferenceThisInHere {
+>CannotReferenceThisInHere : typeof CannotReferenceThisInHere
+
+    let f1 = (this: number) => {
+>f1 : (this: number) => void
+>(this: number) => {        // Test that the erroneously specified "this" type is not being used.        let that = this;    } : (this: number) => void
+>this : number
+
+        // Test that the erroneously specified "this" type is not being used.
+        let that = this;
+>that : any
+>this : any
+
+    };
+    let f2 = <T>(this: number) => {
+>f2 : <T>(this: number) => void
+><T>(this: number) => {        let that = this;    } : <T>(this: number) => void
+>T : T
+>this : number
+
+        let that = this;
+>that : any
+>this : any
+
+    };
+    let f3 = async (this: number) => {
+>f3 : (this: number) => Promise<void>
+>async (this: number) => {        let that = this;    } : (this: number) => Promise<void>
+>this : number
+
+        let that = this;
+>that : any
+>this : any
+
+    };
+    let f4 = async <T>(this: number) => {
+>f4 : <T>(this: number) => Promise<void>
+>async <T>(this: number) => {        let that = this;    } : <T>(this: number) => Promise<void>
+>T : T
+>this : number
+
+        let that = this;
+>that : any
+>this : any
+
+    };
+}
+

tests/cases/compiler/arrowFunctionWithThisParameter.ts

@@ -0,0 +1,17 @@
+// @target: es6
+
+namespace CannotReferenceThisInHere {
+    let f1 = (this: number) => {
+        // Test that the erroneously specified "this" type is not being used.
+        let that = this;
+    };
+    let f2 = <T>(this: number) => {
+        let that = this;
+    };
+    let f3 = async (this: number) => {
+        let that = this;
+    };
+    let f4 = async <T>(this: number) => {
+        let that = this;
+    };
+}