Fix nullable 'this' type

src/compiler/checker.ts

@@ -11601,7 +11601,7 @@ namespace ts {
                     }
                 }
             }
-            if (compilerOptions.noImplicitThis) {
+            if (noImplicitThis) {
                 const containingLiteral = getContainingObjectLiteral(func);
                 if (containingLiteral) {
                     // We have an object literal method. Check if the containing object literal has a contextual type
@@ -11622,9 +11622,9 @@ namespace ts {
                         type = getApparentTypeOfContextualType(literal);
                     }
                     // There was no contextual ThisType<T> for the containing object literal, so the contextual type
-                    // for 'this' is the contextual type for the containing object literal or the type of the object
-                    // literal itself.
-                    return contextualType || checkExpressionCached(containingLiteral);
+                    // for 'this' is the non-null form of the contextual type for the containing object literal or
+                    // the type of the object literal itself.
+                    return contextualType ? getNonNullableType(contextualType) : checkExpressionCached(containingLiteral);
                 }
                 // In an assignment of the form 'obj.xxx = function(...)' or 'obj[xxx] = function(...)', the
                 // contextual type for 'this' is 'obj'.

tests/baselines/reference/thisTypeInObjectLiterals2.js

@@ -47,6 +47,42 @@ let p1: Point = {
     }
 };
 
+let p2: Point | null = {
+    x: 10,
+    y: 20,
+    moveBy(dx, dy, dz) {
+        this.x += dx;
+        this.y += dy;
+        if (this.z && dz) {
+            this.z += dz;
+        }
+    }
+};
+
+let p3: Point | undefined = {
+    x: 10,
+    y: 20,
+    moveBy(dx, dy, dz) {
+        this.x += dx;
+        this.y += dy;
+        if (this.z && dz) {
+            this.z += dz;
+        }
+    }
+};
+
+let p4: Point | null | undefined = {
+    x: 10,
+    y: 20,
+    moveBy(dx, dy, dz) {
+        this.x += dx;
+        this.y += dy;
+        if (this.z && dz) {
+            this.z += dz;
+        }
+    }
+};
+
 declare function f1(p: Point): void;
 
 f1({
@@ -61,6 +97,20 @@ f1({
     }
 });
 
+declare function f2(p: Point | null | undefined): void;
+
+f2({
+    x: 10,
+    y: 20,
+    moveBy(dx, dy, dz) {
+        this.x += dx;
+        this.y += dy;
+        if (this.z && dz) {
+            this.z += dz;
+        }
+    }
+});
+
 // In methods of an object literal with a contextual type that includes some
 // ThisType<T>, 'this' is of type T.
 
@@ -196,6 +246,7 @@ vue.hello;
 //// [thisTypeInObjectLiterals2.js]
 // In methods of an object literal with no contextual type, 'this' has the type
 // of the object literal.
+"use strict";
 var obj1 = {
     a: 1,
     f: function () {
@@ -228,6 +279,39 @@ var p1 = {
         }
     }
 };
+var p2 = {
+    x: 10,
+    y: 20,
+    moveBy: function (dx, dy, dz) {
+        this.x += dx;
+        this.y += dy;
+        if (this.z && dz) {
+            this.z += dz;
+        }
+    }
+};
+var p3 = {
+    x: 10,
+    y: 20,
+    moveBy: function (dx, dy, dz) {
+        this.x += dx;
+        this.y += dy;
+        if (this.z && dz) {
+            this.z += dz;
+        }
+    }
+};
+var p4 = {
+    x: 10,
+    y: 20,
+    moveBy: function (dx, dy, dz) {
+        this.x += dx;
+        this.y += dy;
+        if (this.z && dz) {
+            this.z += dz;
+        }
+    }
+};
 f1({
     x: 10,
     y: 20,
@@ -239,6 +323,17 @@ f1({
         }
     }
 });
+f2({
+    x: 10,
+    y: 20,
+    moveBy: function (dx, dy, dz) {
+        this.x += dx;
+        this.y += dy;
+        if (this.z && dz) {
+            this.z += dz;
+        }
+    }
+});
 var x1 = makeObject({
     data: { x: 0, y: 0 },
     methods: {
@@ -328,7 +423,11 @@ declare type Point = {
     moveBy(dx: number, dy: number, dz?: number): void;
 };
 declare let p1: Point;
+declare let p2: Point | null;
+declare let p3: Point | undefined;
+declare let p4: Point | null | undefined;
 declare function f1(p: Point): void;
+declare function f2(p: Point | null | undefined): void;
 declare type ObjectDescriptor<D, M> = {
     data?: D;
     methods?: M & ThisType<D & M>;