From 21c43009a667103d3818c6b3a03bcde1ca6654d6 Mon Sep 17 00:00:00 2001
From: Anders Hejlsberg <andersh@microsoft.com>
Date: Tue, 28 Feb 2017 16:09:24 -0800
Subject: [PATCH] Enable new behavior only in --noImplicitThis mode

---
 src/compiler/checker.ts | 58 +++++++++++++++++++++--------------------
 1 file changed, 30 insertions(+), 28 deletions(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index a5c0f1819cb..6fb2e497a8d 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -11570,36 +11570,38 @@ namespace ts {
                     }
                 }
             }
-            const containingLiteral = getContainingObjectLiteral(func);
-            if (containingLiteral) {
-                // We have an object literal method. Check if the containing object literal has a contextual type
-                // that includes a ThisType<T>. If so, T is the contextual type for 'this'. We continue looking in
-                // any directly enclosing object literals.
-                const contextualType = getApparentTypeOfContextualType(containingLiteral);
-                let literal = containingLiteral;
-                let type = contextualType;
-                while (type) {
-                    const thisType = getThisTypeFromContextualType(type);
-                    if (thisType) {
-                        return instantiateType(thisType, getContextualMapper(containingLiteral));
+            if (compilerOptions.noImplicitThis) {
+                const containingLiteral = getContainingObjectLiteral(func);
+                if (containingLiteral) {
+                    // We have an object literal method. Check if the containing object literal has a contextual type
+                    // that includes a ThisType<T>. If so, T is the contextual type for 'this'. We continue looking in
+                    // any directly enclosing object literals.
+                    const contextualType = getApparentTypeOfContextualType(containingLiteral);
+                    let literal = containingLiteral;
+                    let type = contextualType;
+                    while (type) {
+                        const thisType = getThisTypeFromContextualType(type);
+                        if (thisType) {
+                            return instantiateType(thisType, getContextualMapper(containingLiteral));
+                        }
+                        if (literal.parent.kind !== SyntaxKind.PropertyAssignment) {
+                            break;
+                        }
+                        literal = <ObjectLiteralExpression>literal.parent.parent;
+                        type = getApparentTypeOfContextualType(literal);
                     }
-                    if (literal.parent.kind !== SyntaxKind.PropertyAssignment) {
-                        break;
-                    }
-                    literal = <ObjectLiteralExpression>literal.parent.parent;
-                    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);
                 }
-                // 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);
-            }
-            // 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);
+                // 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;