Typed 'this' in object literal methods

src/compiler/checker.ts

@@ -257,6 +257,7 @@ namespace ts {
         let globalNumberType: ObjectType;
         let globalBooleanType: ObjectType;
         let globalRegExpType: ObjectType;
+        let globalThisType: GenericType;
         let anyArrayType: Type;
         let autoArrayType: Type;
         let anyReadonlyArrayType: Type;
@@ -6040,6 +6041,11 @@ namespace ts {
             return deferredGlobalIterableIteratorType || (deferredGlobalIterableIteratorType = getGlobalType("IterableIterator", /*arity*/ 1, reportErrors)) || emptyGenericType;
         }
 
+        function getGlobalTypeOrUndefined(name: string, arity = 0): ObjectType {
+            const symbol = getGlobalSymbol(name, SymbolFlags.Type, /*diagnostic*/ undefined);
+            return symbol && <GenericType>getTypeOfGlobalSymbol(symbol, arity);
+        }
+
         /**
          * Returns a type that is inside a namespace at the global scope, e.g.
          * getExportedTypeFromNamespace('JSX', 'Element') returns the JSX.Element type
@@ -11464,6 +11470,22 @@ namespace ts {
             }
         }
 
+        function getContainingObjectLiteral(func: FunctionLikeDeclaration) {
+            return func.kind === SyntaxKind.MethodDeclaration && func.parent.kind === SyntaxKind.ObjectLiteralExpression ? <ObjectLiteralExpression>func.parent :
+                func.kind === SyntaxKind.FunctionExpression && func.parent.kind === SyntaxKind.PropertyAssignment ? <ObjectLiteralExpression>func.parent.parent :
+                undefined;
+        }
+
+        function getThisTypeArgument(type: Type): Type {
+            return getObjectFlags(type) & ObjectFlags.Reference && (<TypeReference>type).target === globalThisType ? (<TypeReference>type).typeArguments[0] : undefined;
+        }
+
+        function getThisTypeFromContextualType(type: Type): Type {
+            return applyToContextualType(type, t => {
+                return t.flags & TypeFlags.Intersection ? forEach((<IntersectionType>t).types, getThisTypeArgument) : getThisTypeArgument(t);
+            });
+        }
+
         function getContextualThisParameterType(func: FunctionLikeDeclaration): Type {
             if (isContextSensitiveFunctionOrObjectLiteralMethod(func) && func.kind !== SyntaxKind.ArrowFunction) {
                 const contextualSignature = getContextualSignature(func);
@@ -11473,6 +11495,37 @@ namespace ts {
                         return getTypeOfSymbol(thisParameter);
                     }
                 }
+                const containingLiteral = getContainingObjectLiteral(func);
+                if (containingLiteral) {
+                    // We have an object literal method. Check if the containing object literal has a contextual type
+                    // and if that contextual type is or includes a ThisType<T>. If so, T is the contextual type for
+                    // 'this'. We continue looking in any directly enclosing object literals.
+                    let objectLiteral = containingLiteral;
+                    while (true) {
+                        const type = getApparentTypeOfContextualType(objectLiteral);
+                        if (type) {
+                            const thisType = getThisTypeFromContextualType(type);
+                            if (thisType) {
+                                return thisType;
+                            }
+                        }
+                        if (objectLiteral.parent.kind !== SyntaxKind.PropertyAssignment) {
+                            break;
+                        }
+                        objectLiteral = <ObjectLiteralExpression>objectLiteral.parent.parent;
+                    }
+                    // There was no contextual ThisType<T> for the containing object literal, so the contextual type
+                    // for 'this' is the type of the object literal itself.
+                    return checkExpressionCached(containingLiteral);
+                }
+                // In an assignment of the form 'obj.xxx = function(...)' or 'obj[xxx] = function(...)', the
+                // contextual type for 'this' is 'obj'.
+                if (func.parent.kind === SyntaxKind.BinaryExpression && (<BinaryExpression>func.parent).operatorToken.kind === SyntaxKind.EqualsToken) {
+                    const target = (<BinaryExpression>func.parent).left;
+                    if (target.kind === SyntaxKind.PropertyAccessExpression || target.kind === SyntaxKind.ElementAccessExpression) {
+                        return checkExpressionCached((<PropertyAccessExpression | ElementAccessExpression>target).expression);
+                    }
+                }
             }
             return undefined;
         }
@@ -21921,9 +21974,9 @@ namespace ts {
             anyArrayType = createArrayType(anyType);
             autoArrayType = createArrayType(autoType);
 
-            const symbol = getGlobalSymbol("ReadonlyArray", SymbolFlags.Type, /*diagnostic*/ undefined);
-            globalReadonlyArrayType = symbol && <GenericType>getTypeOfGlobalSymbol(symbol, /*arity*/ 1);
+            globalReadonlyArrayType = <GenericType>getGlobalTypeOrUndefined("ReadonlyArray", /*arity*/ 1);
             anyReadonlyArrayType = globalReadonlyArrayType ? createTypeFromGenericGlobalType(globalReadonlyArrayType, [anyType]) : anyArrayType;
+            globalThisType = <GenericType>getGlobalTypeOrUndefined("ThisType", /*arity*/ 1);
         }
 
         function checkExternalEmitHelpers(location: Node, helpers: ExternalEmitHelpers) {

src/lib/es5.d.ts

@@ -1366,6 +1366,11 @@ type Record<K extends string, T> = {
     [P in K]: T;
 }
 
+/**
+ * Marker for contextual 'this' type
+ */
+interface ThisType<T> { }
+
 /**
   * Represents a raw buffer of binary data, which is used to store data for the
   * different typed arrays. ArrayBuffers cannot be read from or written to directly,

tests/baselines/reference/castTest.symbols

@@ -71,7 +71,13 @@ var p_cast = <Point> ({
 
         return new Point(this.x + dx, this.y + dy);
 >Point : Symbol(Point, Decl(castTest.ts, 11, 37))
+>this.x : Symbol(x, Decl(castTest.ts, 22, 23))
+>this : Symbol(__object, Decl(castTest.ts, 22, 22))
+>x : Symbol(x, Decl(castTest.ts, 22, 23))
 >dx : Symbol(dx, Decl(castTest.ts, 25, 18))
+>this.y : Symbol(y, Decl(castTest.ts, 23, 9))
+>this : Symbol(__object, Decl(castTest.ts, 22, 22))
+>y : Symbol(y, Decl(castTest.ts, 23, 9))
 >dy : Symbol(dy, Decl(castTest.ts, 25, 21))
 
     },

tests/baselines/reference/castTest.types

@@ -91,15 +91,15 @@ var p_cast = <Point> ({
         return new Point(this.x + dx, this.y + dy);
 >new Point(this.x + dx, this.y + dy) : Point
 >Point : typeof Point
->this.x + dx : any
->this.x : any
->this : any
->x : any
+>this.x + dx : number
+>this.x : number
+>this : { x: number; y: number; add: (dx: number, dy: number) => Point; mult: (p: Point) => Point; }
+>x : number
 >dx : number
->this.y + dy : any
->this.y : any
->this : any
->y : any
+>this.y + dy : number
+>this.y : number
+>this : { x: number; y: number; add: (dx: number, dy: number) => Point; mult: (p: Point) => Point; }
+>y : number
 >dy : number
 
     },

tests/baselines/reference/commentsOnObjectLiteral2.errors.txt

@@ -1,7 +1,8 @@
 tests/cases/compiler/commentsOnObjectLiteral2.ts(1,14): error TS2304: Cannot find name 'makeClass'.
+tests/cases/compiler/commentsOnObjectLiteral2.ts(9,17): error TS2339: Property 'name' does not exist on type '{ initialize: (name: any) => void; }'.
 
 
-==== tests/cases/compiler/commentsOnObjectLiteral2.ts (1 errors) ====
+==== tests/cases/compiler/commentsOnObjectLiteral2.ts (2 errors) ====
     var Person = makeClass( 
                  ~~~~~~~~~
 !!! error TS2304: Cannot find name 'makeClass'.
@@ -13,6 +14,8 @@ tests/cases/compiler/commentsOnObjectLiteral2.ts(1,14): error TS2304: Cannot fin
             */ 
            initialize: function(name) { 
                this.name = name; 
+                    ~~~~
+!!! error TS2339: Property 'name' does not exist on type '{ initialize: (name: any) => void; }'.
            } /* trailing comment 1*/, 
        } 
     );

tests/baselines/reference/declarationEmitThisPredicates02.errors.txt

@@ -13,7 +13,7 @@ tests/cases/conformance/declarationEmit/typePredicates/declarationEmitThisPredic
         m(): this is Foo {
              ~~~~
 !!! error TS2526: A 'this' type is available only in a non-static member of a class or interface.
-            let dis = this as Foo;
+            let dis = this as {} as Foo;
             return dis.a != null && dis.b != null && dis.c != null;
         }
     }

tests/baselines/reference/declarationEmitThisPredicates02.js

@@ -8,7 +8,7 @@ export interface Foo {
 
 export const obj = {
     m(): this is Foo {
-        let dis = this as Foo;
+        let dis = this as {} as Foo;
         return dis.a != null && dis.b != null && dis.c != null;
     }
 }

tests/baselines/reference/declarationEmitThisPredicatesWithPrivateName02.errors.txt

@@ -16,7 +16,7 @@ tests/cases/conformance/declarationEmit/typePredicates/declarationEmitThisPredic
         m(): this is Foo {
              ~~~~
 !!! error TS2526: A 'this' type is available only in a non-static member of a class or interface.
-            let dis = this as Foo;
+            let dis = this as {} as Foo;
             return dis.a != null && dis.b != null && dis.c != null;
         }
     }

tests/baselines/reference/declarationEmitThisPredicatesWithPrivateName02.js

@@ -8,7 +8,7 @@ interface Foo {
 
 export const obj = {
     m(): this is Foo {
-        let dis = this as Foo;
+        let dis = this as {} as Foo;
         return dis.a != null && dis.b != null && dis.c != null;
     }
 }

tests/baselines/reference/fatarrowfunctions.symbols

@@ -163,6 +163,11 @@ var messenger = {
 
         setTimeout(() => { this.message.toString(); }, 3000);
 >setTimeout : Symbol(setTimeout, Decl(fatarrowfunctions.ts, 34, 1))
+>this.message.toString : Symbol(String.toString, Decl(lib.d.ts, --, --))
+>this.message : Symbol(message, Decl(fatarrowfunctions.ts, 38, 17))
+>this : Symbol(messenger, Decl(fatarrowfunctions.ts, 38, 15))
+>message : Symbol(message, Decl(fatarrowfunctions.ts, 38, 17))
+>toString : Symbol(String.toString, Decl(lib.d.ts, --, --))
     }
 };
 

tests/baselines/reference/fatarrowfunctions.types

@@ -234,12 +234,12 @@ var messenger = {
 >setTimeout(() => { this.message.toString(); }, 3000) : number
 >setTimeout : (expression: any, msec?: number, language?: any) => number
 >() => { this.message.toString(); } : () => void
->this.message.toString() : any
->this.message.toString : any
->this.message : any
->this : any
->message : any
->toString : any
+>this.message.toString() : string
+>this.message.toString : () => string
+>this.message : string
+>this : { message: string; start: () => void; }
+>message : string
+>toString : () => string
 >3000 : 3000
     }
 };

tests/baselines/reference/fatarrowfunctionsInFunctions.symbols

@@ -16,12 +16,17 @@ var messenger = {
 
         var _self = this;
 >_self : Symbol(_self, Decl(fatarrowfunctionsInFunctions.ts, 5, 11))
+>this : Symbol(messenger, Decl(fatarrowfunctionsInFunctions.ts, 2, 15))
 
         setTimeout(function() {
 >setTimeout : Symbol(setTimeout, Decl(fatarrowfunctionsInFunctions.ts, 0, 0))
 
             _self.message.toString(); 
+>_self.message.toString : Symbol(String.toString, Decl(lib.d.ts, --, --))
+>_self.message : Symbol(message, Decl(fatarrowfunctionsInFunctions.ts, 2, 17))
 >_self : Symbol(_self, Decl(fatarrowfunctionsInFunctions.ts, 5, 11))
+>message : Symbol(message, Decl(fatarrowfunctionsInFunctions.ts, 2, 17))
+>toString : Symbol(String.toString, Decl(lib.d.ts, --, --))
 
         }, 3000); 
     }

tests/baselines/reference/fatarrowfunctionsInFunctions.types

@@ -18,21 +18,21 @@ var messenger = {
 >function() {        var _self = this;        setTimeout(function() {            _self.message.toString();         }, 3000);     } : () => void
 
         var _self = this;
->_self : any
->this : any
+>_self : { message: string; start: () => void; }
+>this : { message: string; start: () => void; }
 
         setTimeout(function() {
 >setTimeout(function() {            _self.message.toString();         }, 3000) : number
 >setTimeout : (expression: any, msec?: number, language?: any) => number
 >function() {            _self.message.toString();         } : () => void
 
             _self.message.toString(); 
->_self.message.toString() : any
->_self.message.toString : any
->_self.message : any
->_self : any
->message : any
->toString : any
+>_self.message.toString() : string
+>_self.message.toString : () => string
+>_self.message : string
+>_self : { message: string; start: () => void; }
+>message : string
+>toString : () => string
 
         }, 3000); 
 >3000 : 3000