Add --noImplicitThis flag

sandersn · sandersn · commit a91cdccfc509 · 2016-03-25T16:37:28.000-07:00
It's basically another --noImplicitAny error, but one that would break
large amount of JavaScript-style code.
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
@@ -7707,6 +7707,10 @@ namespace ts {
                 }
             }
 
+            if (compilerOptions.noImplicitThis && isFunctionLike(container)) {
+                // With noImplicitThis, functions may not reference 'this' if it has type 'any'
+                error(node, Diagnostics.this_implicitly_has_type_any_because_it_does_not_have_a_type_annotation);
+            }
             return anyType;
         }
 
diff --git a/src/compiler/commandLineParser.ts b/src/compiler/commandLineParser.ts
@@ -125,6 +125,10 @@ namespace ts {
             type: "boolean",
             description: Diagnostics.Raise_error_on_expressions_and_declarations_with_an_implied_any_type,
         },
+        {
+            name: "noImplicitThis",
+            type: "boolean",
+        },
         {
             name: "noLib",
             type: "boolean",
diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json
@@ -1863,7 +1863,11 @@
         "category": "Error",
         "code": 2680
     },
-    "Import declaration '{0}' is using private name '{1}'.": {
+    "'this' implicitly has type 'any' because it does not have a type annotation.": {
+        "category": "Error",
+        "code": 2681
+    },
+   "Import declaration '{0}' is using private name '{1}'.": {
         "category": "Error",
         "code": 4000
     },
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
@@ -2395,6 +2395,7 @@ namespace ts {
         noEmitOnError?: boolean;
         noErrorTruncation?: boolean;
         noImplicitAny?: boolean;
+        noImplicitThis?: boolean;
         noLib?: boolean;
         noResolve?: boolean;
         out?: string;
diff --git a/tests/baselines/reference/noImplicitThisFunctions.errors.txt b/tests/baselines/reference/noImplicitThisFunctions.errors.txt
@@ -0,0 +1,25 @@
+tests/cases/compiler/noImplicitThisFunctions.ts(14,12): error TS2681: 'this' implicitly has type 'any' because it does not have a type annotation.
+
+
+==== tests/cases/compiler/noImplicitThisFunctions.ts (1 errors) ====
+    
+    function f1(x) {
+        // implicit any is still allowed
+        return x + 1;
+    }
+    
+    function f2(y: number) {
+        // ok: no reference to this
+        return y + 1;
+    }
+    
+    function f3(z: number): number {
+        // error: this is implicitly any
+        return this.a + z;
+               ~~~~
+!!! error TS2681: 'this' implicitly has type 'any' because it does not have a type annotation.
+    }
+    
+    // ok, arrow functions don't even bind `this`, so `this` is just `window`
+    let f4: (b: number) => number = b => this.c + b;
+    
diff --git a/tests/baselines/reference/noImplicitThisFunctions.js b/tests/baselines/reference/noImplicitThisFunctions.js
@@ -0,0 +1,37 @@
+//// [noImplicitThisFunctions.ts]
+
+function f1(x) {
+    // implicit any is still allowed
+    return x + 1;
+}
+
+function f2(y: number) {
+    // ok: no reference to this
+    return y + 1;
+}
+
+function f3(z: number): number {
+    // error: this is implicitly any
+    return this.a + z;
+}
+
+// ok, arrow functions don't even bind `this`, so `this` is just `window`
+let f4: (b: number) => number = b => this.c + b;
+
+
+//// [noImplicitThisFunctions.js]
+var _this = this;
+function f1(x) {
+    // implicit any is still allowed
+    return x + 1;
+}
+function f2(y) {
+    // ok: no reference to this
+    return y + 1;
+}
+function f3(z) {
+    // error: this is implicitly any
+    return this.a + z;
+}
+// ok, arrow functions don't even bind `this`, so `this` is just `window`
+var f4 = function (b) { return _this.c + b; };
diff --git a/tests/cases/compiler/noImplicitThisFunctions.ts b/tests/cases/compiler/noImplicitThisFunctions.ts
@@ -0,0 +1,19 @@
+// @noImplicitThis: true
+
+function f1(x) {
+    // implicit any is still allowed
+    return x + 1;
+}
+
+function f2(y: number) {
+    // ok: no reference to this
+    return y + 1;
+}
+
+function f3(z: number): number {
+    // error: this is implicitly any
+    return this.a + z;
+}
+
+// ok, arrow functions don't even bind `this`, so `this` is just `window`
+let f4: (b: number) => number = b => this.c + b;

Original file line number	Diff line number	Diff line change
`@@ -7707,6 +7707,10 @@ namespace ts {`
`7707`	`7707`	`}`
`7708`	`7708`	`}`
`7709`	`7709`
	`7710`	`+ if (compilerOptions.noImplicitThis && isFunctionLike(container)) {`
	`7711`	`+ // With noImplicitThis, functions may not reference 'this' if it has type 'any'`
	`7712`	`+ error(node, Diagnostics.this_implicitly_has_type_any_because_it_does_not_have_a_type_annotation);`
	`7713`	`+ }`
`7710`	`7714`	`return anyType;`
`7711`	`7715`	`}`
`7712`	`7716`