Merge branch 'master' into falseAssertions

Author: ahejlsberg

README.md

@@ -42,7 +42,7 @@ with any additional questions or comments.
 
 ## Documentation
 
-*  [Quick tutorial](https://www.typescriptlang.org/docs/tutorial.html)
+*  [TypeScript in 5 minutes](https://www.typescriptlang.org/docs/handbook/typescript-in-5-minutes.html)
 *  [Programming handbook](https://www.typescriptlang.org/docs/handbook/basic-types.html)
 *  [Language specification](https://github.com/microsoft/TypeScript/blob/master/doc/spec.md)
 *  [Homepage](https://www.typescriptlang.org/)

package.json

@@ -54,9 +54,9 @@
         "@types/through2": "latest",
         "@types/travis-fold": "latest",
         "@types/xml2js": "^0.4.0",
-        "@typescript-eslint/eslint-plugin": "2.2.0",
-        "@typescript-eslint/experimental-utils": "2.2.0",
-        "@typescript-eslint/parser": "2.2.0",
+        "@typescript-eslint/eslint-plugin": "2.3.2",
+        "@typescript-eslint/experimental-utils": "2.3.2",
+        "@typescript-eslint/parser": "2.3.2",
         "async": "latest",
         "azure-devops-node-api": "^8.0.0",
         "browser-resolve": "^1.11.2",
@@ -65,10 +65,10 @@
         "chalk": "latest",
         "convert-source-map": "latest",
         "del": "5.1.0",
-        "eslint": "6.3.0",
+        "eslint": "6.5.1",
         "eslint-formatter-autolinkable-stylish": "1.0.3",
         "eslint-plugin-import": "2.18.2",
-        "eslint-plugin-jsdoc": "15.9.1",
+        "eslint-plugin-jsdoc": "15.9.9",
         "eslint-plugin-no-null": "1.0.2",
         "fancy-log": "latest",
         "fs-extra": "^6.0.1",

src/compiler/binder.ts

@@ -856,9 +856,8 @@ namespace ts {
         function isNarrowableReference(expr: Expression): boolean {
             return expr.kind === SyntaxKind.Identifier || expr.kind === SyntaxKind.ThisKeyword || expr.kind === SyntaxKind.SuperKeyword ||
                 (isPropertyAccessExpression(expr) || isNonNullExpression(expr) || isParenthesizedExpression(expr)) && isNarrowableReference(expr.expression) ||
-                isElementAccessExpression(expr) &&
-                isStringOrNumericLiteralLike(expr.argumentExpression) &&
-                isNarrowableReference(expr.expression);
+                isElementAccessExpression(expr) && isStringOrNumericLiteralLike(expr.argumentExpression) && isNarrowableReference(expr.expression) ||
+                isOptionalChain(expr);
         }
 
         function hasNarrowableArgument(expr: CallExpression) {

src/compiler/checker.ts

@@ -18124,6 +18124,16 @@ namespace ts {
             return false;
         }
 
+        function optionalChainContainsReference(source: Node, target: Node) {
+            while (isOptionalChain(source)) {
+                source = source.expression;
+                if (isMatchingReference(source, target)) {
+                    return true;
+                }
+            }
+            return false;
+        }
+
         // Return true if target is a property access xxx.yyy, source is a property access xxx.zzz, the declared
         // type of xxx is a union type, and yyy is a property that is possibly a discriminant. We consider a property
         // a possible discriminant if its type differs in the constituents of containing union type, and if every
@@ -19378,6 +19388,14 @@ namespace ts {
                         if (isMatchingReference(reference, right)) {
                             return narrowTypeByEquality(type, operator, left, assumeTrue);
                         }
+                        if (assumeTrue && strictNullChecks) {
+                            if (optionalChainContainsReference(left, reference)) {
+                                type = narrowTypeByOptionalChainContainment(type, operator, right);
+                            }
+                            else if (optionalChainContainsReference(right, reference)) {
+                                type = narrowTypeByOptionalChainContainment(type, operator, left);
+                            }
+                        }
                         if (isMatchingReferenceDiscriminant(left, declaredType)) {
                             return narrowTypeByDiscriminant(type, <AccessExpression>left, t => narrowTypeByEquality(t, operator, right, assumeTrue));
                         }
@@ -19402,6 +19420,18 @@ namespace ts {
                 return type;
             }
 
+            function narrowTypeByOptionalChainContainment(type: Type, operator: SyntaxKind, value: Expression): Type {
+                // We are in the true branch of obj?.foo === value or obj?.foo !== value. We remove undefined and null from
+                // the type of obj if (a) the operator is === and the type of value doesn't include undefined or (b) the
+                // operator is !== and the type of value is undefined.
+                const valueType = getTypeOfExpression(value);
+                return operator === SyntaxKind.EqualsEqualsToken && !(getTypeFacts(valueType) & TypeFacts.EQUndefinedOrNull) ||
+                    operator === SyntaxKind.EqualsEqualsEqualsToken && !(getTypeFacts(valueType) & TypeFacts.EQUndefined) ||
+                    operator === SyntaxKind.ExclamationEqualsToken && valueType.flags & TypeFlags.Nullable ||
+                    operator === SyntaxKind.ExclamationEqualsEqualsToken && valueType.flags & TypeFlags.Undefined ?
+                    getTypeWithFacts(type, TypeFacts.NEUndefinedOrNull) : type;
+            }
+
             function narrowTypeByEquality(type: Type, operator: SyntaxKind, value: Expression, assumeTrue: boolean): Type {
                 if (type.flags & TypeFlags.Any) {
                     return type;
@@ -19452,6 +19482,10 @@ namespace ts {
                 // We have '==', '!=', '===', or !==' operator with 'typeof xxx' and string literal operands
                 const target = getReferenceCandidate(typeOfExpr.expression);
                 if (!isMatchingReference(reference, target)) {
+                    if (assumeTrue && (operator === SyntaxKind.EqualsEqualsToken || operator === SyntaxKind.EqualsEqualsEqualsToken) &&
+                        strictNullChecks && optionalChainContainsReference(target, reference)) {
+                        return getTypeWithFacts(type, TypeFacts.NEUndefinedOrNull);
+                    }
                     // For a reference of the form 'x.y', a 'typeof x === ...' type guard resets the
                     // narrowed type of 'y' to its declared type.
                     if (containsMatchingReference(reference, target)) {
@@ -19633,6 +19667,9 @@ namespace ts {
             function narrowTypeByInstanceof(type: Type, expr: BinaryExpression, assumeTrue: boolean): Type {
                 const left = getReferenceCandidate(expr.left);
                 if (!isMatchingReference(reference, left)) {
+                    if (assumeTrue && strictNullChecks && optionalChainContainsReference(left, reference)) {
+                        return getTypeWithFacts(type, TypeFacts.NEUndefinedOrNull);
+                    }
                     // For a reference of the form 'x.y', an 'x instanceof T' type guard resets the
                     // narrowed type of 'y' to its declared type. We do this because preceding 'x.y'
                     // references might reference a different 'y' property. However, we make an exception
@@ -23621,7 +23658,20 @@ namespace ts {
                 // If the signature's 'this' type is voidType, then the check is skipped -- anything is compatible.
                 // If the expression is a new expression, then the check is skipped.
                 const thisArgumentNode = getThisArgumentOfCall(node);
-                const thisArgumentType = thisArgumentNode ? checkExpression(thisArgumentNode) : voidType;
+                let thisArgumentType: Type;
+                if (thisArgumentNode) {
+                    thisArgumentType = checkExpression(thisArgumentNode);
+                    if (isOptionalChainRoot(thisArgumentNode.parent)) {
+                        thisArgumentType = getNonNullableType(thisArgumentType);
+                    }
+                    else if (isOptionalChain(thisArgumentNode.parent)) {
+                        thisArgumentType = removeOptionalTypeMarker(thisArgumentType);
+                    }
+                }
+                else {
+                    thisArgumentType = voidType;
+                }
+
                 const errorNode = reportErrors ? (thisArgumentNode || node) : undefined;
                 const headMessage = Diagnostics.The_this_context_of_type_0_is_not_assignable_to_method_s_this_of_type_1;
                 if (!checkTypeRelatedTo(thisArgumentType, thisType, relation, errorNode, headMessage, containingMessageChain, errorOutputContainer)) {

src/compiler/utilities.ts

@@ -2174,9 +2174,11 @@ namespace ts {
                 nextToLast = nextToLast.expression as Exclude<BindableStaticNameExpression, Identifier>;
             }
             const id = nextToLast.expression;
-            if (id.escapedText === "exports" ||
-                id.escapedText === "module" && getElementOrPropertyAccessName(nextToLast) === "exports") {
-                // exports.name = expr OR module.exports.name = expr
+            if ((id.escapedText === "exports" ||
+                id.escapedText === "module" && getElementOrPropertyAccessName(nextToLast) === "exports") &&
+                // ExportsProperty does not support binding with computed names
+                isBindableStaticAccessExpression(lhs)) {
+                // exports.name = expr OR module.exports.name = expr OR exports["name"] = expr ...
                 return AssignmentDeclarationKind.ExportsProperty;
             }
             // F.G...x = expr