Enable new behavior only in --noImplicitThis mode

Author: ahejlsberg

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 (literal.parent.kind !== SyntaxKind.PropertyAssignment) {
-                        break;
+            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);
                     }
-                    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;