@typescript-deploys/pr-build 4.8.0-pr-49091-7 → 4.8.0-pr-49086-10

package/lib/tsc.js

@@ -6079,6 +6079,7 @@ var ts;
         Import_assertions_are_not_allowed_on_statements_that_transpile_to_commonjs_require_calls: diag(2836, ts.DiagnosticCategory.Error, "Import_assertions_are_not_allowed_on_statements_that_transpile_to_commonjs_require_calls_2836", "Import assertions are not allowed on statements that transpile to commonjs 'require' calls."),
         Import_assertion_values_must_be_string_literal_expressions: diag(2837, ts.DiagnosticCategory.Error, "Import_assertion_values_must_be_string_literal_expressions_2837", "Import assertion values must be string literal expressions."),
         All_declarations_of_0_must_have_identical_constraints: diag(2838, ts.DiagnosticCategory.Error, "All_declarations_of_0_must_have_identical_constraints_2838", "All declarations of '{0}' must have identical constraints."),
+        This_condition_will_always_return_0_since_JavaScript_compares_objects_by_reference_not_value: diag(2839, ts.DiagnosticCategory.Error, "This_condition_will_always_return_0_since_JavaScript_compares_objects_by_reference_not_value_2839", "This condition will always return '{0}' since JavaScript compares objects by reference, not value."),
         Import_declaration_0_is_using_private_name_1: diag(4000, ts.DiagnosticCategory.Error, "Import_declaration_0_is_using_private_name_1_4000", "Import declaration '{0}' is using private name '{1}'."),
         Type_parameter_0_of_exported_class_has_or_is_using_private_name_1: diag(4002, ts.DiagnosticCategory.Error, "Type_parameter_0_of_exported_class_has_or_is_using_private_name_1_4002", "Type parameter '{0}' of exported class has or is using private name '{1}'."),
         Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1: diag(4004, ts.DiagnosticCategory.Error, "Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1_4004", "Type parameter '{0}' of exported interface has or is using private name '{1}'."),
@@ -9904,6 +9905,18 @@ var ts;
         return isLiteralKind(node.kind);
     }
     ts.isLiteralExpression = isLiteralExpression;
+    function isLiteralExpressionOfObject(node) {
+        switch (node.kind) {
+            case 205:
+            case 204:
+            case 13:
+            case 213:
+            case 226:
+                return true;
+        }
+        return false;
+    }
+    ts.isLiteralExpressionOfObject = isLiteralExpressionOfObject;
     function isTemplateLiteralKind(kind) {
         return 14 <= kind && kind <= 17;
     }
@@ -54439,18 +54452,6 @@ var ts;
                 }
                 return result;
             }
-            function removeIntersectionMembersWithoutKeys(type) {
-                if (!(type.flags & 2097152)) {
-                    return type;
-                }
-                return getIntersectionType(ts.filter(type.types, function (t) { return !isKeylessType(t); }));
-            }
-            function isKeylessType(type) {
-                return !!(getIndexType(type).flags & 131072);
-            }
-            function isConditionalFilteringKeylessTypes(type) {
-                return !!(type.flags & 16777216) && type.root.isDistributive && everyType(type.extendsType, isKeylessType);
-            }
             function structuredTypeRelatedTo(source, target, reportErrors, intersectionState) {
                 if (intersectionState & 4) {
                     return propertiesRelatedTo(source, target, reportErrors, undefined, 0);
@@ -54559,28 +54560,9 @@ var ts;
                 else if (targetFlags & 4194304) {
                     var targetType_1 = target.type;
                     if (sourceFlags & 4194304) {
-                        var sourceType = source.type;
-                        if (result = isRelatedTo(targetType_1, sourceType, 3, false)) {
+                        if (result = isRelatedTo(targetType_1, source.type, 3, false)) {
                             return result;
                         }
-                        while (isConditionalFilteringKeylessTypes(sourceType)) {
-                            var lastSource = sourceType;
-                            sourceType = getDefaultConstraintOfConditionalType(sourceType);
-                            if (sourceType === lastSource) {
-                                break;
-                            }
-                            if (result = isRelatedTo(targetType_1, sourceType, 3, false)) {
-                                return result;
-                            }
-                            var simplifiedSource = sourceType;
-                            sourceType = removeIntersectionMembersWithoutKeys(sourceType);
-                            if (sourceType === simplifiedSource) {
-                                continue;
-                            }
-                            if (result = isRelatedTo(targetType_1, sourceType, 3, false)) {
-                                return result;
-                            }
-                        }
                     }
                     if (isTupleType(targetType_1)) {
                         if (result = isRelatedTo(source, getKnownKeysOfTupleType(targetType_1), 2, reportErrors)) {
@@ -56104,11 +56086,15 @@ var ts;
                 type.flags & 1048576 ? mapType(type, getWidenedUniqueESSymbolType) :
                     type;
         }
-        function getWidenedLiteralLikeTypeForContextualType(type, contextualType) {
-            if (!isLiteralOfContextualType(type, contextualType)) {
-                type = getWidenedUniqueESSymbolType(getWidenedLiteralType(type));
+        function getWidenedLiteralLikeTypeForContextualType(type, contextualType, node) {
+            if (isLiteralOfContextualType(type, contextualType)) {
+                return type;
             }
-            return type;
+            var instantiatedContextualType = node && instantiateContextualType(contextualType, node) || contextualType;
+            if (instantiatedContextualType !== contextualType && isLiteralOfContextualType(type, instantiatedContextualType)) {
+                return type;
+            }
+            return getWidenedUniqueESSymbolType(getWidenedLiteralType(type));
         }
         function getWidenedLiteralLikeTypeForContextualReturnTypeIfNeeded(type, contextualSignatureReturnType, isAsync) {
             if (type && isUnitType(type)) {
@@ -56174,21 +56160,13 @@ var ts;
             }
             return result;
         }
-        function getApparentIntersectionTypes(type) {
-            var apparent = getApparentType(type);
-            if (apparent.flags & 2097152) {
-                return apparent.types;
-            }
-            return [apparent];
-        }
         function getFalsyFlags(type) {
             return type.flags & 1048576 ? getFalsyFlagsOfTypes(type.types) :
-                type.flags & 2097152 ? ts.reduceLeft(getApparentIntersectionTypes(type), function (memo, type) { return memo | getFalsyFlags(type); }, 0) :
-                    type.flags & 128 ? type.value === "" ? 128 : 0 :
-                        type.flags & 256 ? type.value === 0 ? 256 : 0 :
-                            type.flags & 2048 ? isZeroBigInt(type) ? 2048 : 0 :
-                                type.flags & 512 ? (type === falseType || type === regularFalseType) ? 512 : 0 :
-                                    type.flags & 117724;
+                type.flags & 128 ? type.value === "" ? 128 : 0 :
+                    type.flags & 256 ? type.value === 0 ? 256 : 0 :
+                        type.flags & 2048 ? isZeroBigInt(type) ? 2048 : 0 :
+                            type.flags & 512 ? (type === falseType || type === regularFalseType) ? 512 : 0 :
+                                type.flags & 117724;
         }
         function removeDefinitelyFalsyTypes(type) {
             return getFalsyFlags(type) & 117632 ?
@@ -59276,9 +59254,7 @@ var ts;
                     case "function":
                         return type.flags & 1 ? type : globalFunctionType;
                     case "object":
-                        var isUnknownish = type.flags & 2 ||
-                            (type.flags & 58982400 && (getBaseConstraintOfType(type) || unknownType).flags & 2);
-                        return isUnknownish ? getUnionType([nonPrimitiveType, nullType]) : type;
+                        return type.flags & 2 ? getUnionType([nonPrimitiveType, nullType]) : type;
                     default:
                         return typeofTypesByName.get(text);
                 }
@@ -60762,16 +60738,16 @@ var ts;
         function instantiateContextualType(contextualType, node, contextFlags) {
             if (contextualType && maybeTypeOfKind(contextualType, 465829888)) {
                 var inferenceContext = getInferenceContext(node);
-                if (inferenceContext && ts.some(inferenceContext.inferences, hasInferenceCandidates)) {
-                    if (contextFlags && contextFlags & 1) {
-                        return instantiateInstantiableTypes(contextualType, inferenceContext.nonFixingMapper);
-                    }
-                    if (inferenceContext.returnMapper) {
-                        var type = instantiateInstantiableTypes(contextualType, inferenceContext.returnMapper);
-                        return type.flags & 1048576 && containsType(type.types, regularFalseType) && containsType(type.types, regularTrueType) ?
-                            filterType(type, function (t) { return t !== regularFalseType && t !== regularTrueType; }) :
-                            type;
-                    }
+                if (inferenceContext && contextFlags & 1 && (inferenceContext.returnMapper || ts.some(inferenceContext.inferences, hasInferenceCandidates))) {
+                    return instantiateInstantiableTypes(contextualType, inferenceContext.returnMapper
+                        ? combineTypeMappers(inferenceContext.nonFixingMapper, inferenceContext.returnMapper)
+                        : inferenceContext.nonFixingMapper);
+                }
+                if (inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.returnMapper) {
+                    var type = instantiateInstantiableTypes(contextualType, inferenceContext.returnMapper);
+                    return type.flags & 1048576 && containsType(type.types, regularFalseType) && containsType(type.types, regularTrueType) ?
+                        filterType(type, function (t) { return t !== regularFalseType && t !== regularTrueType; }) :
+                        type;
                 }
             }
             return contextualType;
@@ -62925,18 +62901,22 @@ var ts;
                 return inferJsxTypeArguments(node, signature, checkMode, context);
             }
             if (node.kind !== 165) {
-                var contextualType = getContextualType(node, ts.every(signature.typeParameters, function (p) { return !!getDefaultFromTypeParameter(p); }) ? 8 : 0);
+                var skipBindingPatterns = ts.every(signature.typeParameters, function (p) { return !!getDefaultFromTypeParameter(p); });
+                var contextualType = getContextualType(node, skipBindingPatterns ? 8 : 0);
                 if (contextualType) {
                     var inferenceTargetType = getReturnTypeOfSignature(signature);
                     if (couldContainTypeVariables(inferenceTargetType)) {
                         var outerContext = getInferenceContext(node);
-                        var outerMapper = getMapperFromContext(cloneInferenceContext(outerContext, 1));
-                        var instantiatedType = instantiateType(contextualType, outerMapper);
-                        var contextualSignature = getSingleCallSignature(instantiatedType);
-                        var inferenceSourceType = contextualSignature && contextualSignature.typeParameters ?
-                            getOrCreateTypeFromSignature(getSignatureInstantiationWithoutFillingInTypeArguments(contextualSignature, contextualSignature.typeParameters)) :
-                            instantiatedType;
-                        inferTypes(context.inferences, inferenceSourceType, inferenceTargetType, 128);
+                        var isFromBindingPattern = !skipBindingPatterns && getContextualType(node, 8) !== contextualType;
+                        if (!isFromBindingPattern) {
+                            var outerMapper = getMapperFromContext(cloneInferenceContext(outerContext, 1));
+                            var instantiatedType = instantiateType(contextualType, outerMapper);
+                            var contextualSignature = getSingleCallSignature(instantiatedType);
+                            var inferenceSourceType = contextualSignature && contextualSignature.typeParameters ?
+                                getOrCreateTypeFromSignature(getSignatureInstantiationWithoutFillingInTypeArguments(contextualSignature, contextualSignature.typeParameters)) :
+                                instantiatedType;
+                            inferTypes(context.inferences, inferenceSourceType, inferenceTargetType, 128);
+                        }
                         var returnContext = createInferenceContext(signature.typeParameters, signature, context.flags);
                         var returnSourceType = instantiateType(contextualType, outerContext && outerContext.returnMapper);
                         inferTypes(returnContext.inferences, returnSourceType, inferenceTargetType);
@@ -66140,6 +66120,10 @@ var ts;
                 case 35:
                 case 36:
                 case 37:
+                    if (ts.isLiteralExpressionOfObject(left) || ts.isLiteralExpressionOfObject(right)) {
+                        var eqType = operator === 34 || operator === 36;
+                        error(errorNode, ts.Diagnostics.This_condition_will_always_return_0_since_JavaScript_compares_objects_by_reference_not_value, eqType ? "false" : "true");
+                    }
                     reportOperatorErrorUnless(function (left, right) { return isTypeEqualityComparableTo(left, right) || isTypeEqualityComparableTo(right, left); });
                     return booleanType;
                 case 102:
@@ -66560,7 +66544,7 @@ var ts;
             var type = checkExpression(node, checkMode, forceTuple);
             return isConstContext(node) || ts.isCommonJsExportedExpression(node) ? getRegularTypeOfLiteralType(type) :
                 isTypeAssertion(node) ? type :
-                    getWidenedLiteralLikeTypeForContextualType(type, instantiateContextualType(arguments.length === 2 ? getContextualType(node) : contextualType, node));
+                    getWidenedLiteralLikeTypeForContextualType(type, arguments.length === 2 ? getContextualType(node) : contextualType, node);
         }
         function checkPropertyAssignment(node, checkMode) {
             if (node.name.kind === 162) {

package/lib/tsserver.js

@@ -8895,6 +8895,7 @@ var ts;
         Import_assertions_are_not_allowed_on_statements_that_transpile_to_commonjs_require_calls: diag(2836, ts.DiagnosticCategory.Error, "Import_assertions_are_not_allowed_on_statements_that_transpile_to_commonjs_require_calls_2836", "Import assertions are not allowed on statements that transpile to commonjs 'require' calls."),
         Import_assertion_values_must_be_string_literal_expressions: diag(2837, ts.DiagnosticCategory.Error, "Import_assertion_values_must_be_string_literal_expressions_2837", "Import assertion values must be string literal expressions."),
         All_declarations_of_0_must_have_identical_constraints: diag(2838, ts.DiagnosticCategory.Error, "All_declarations_of_0_must_have_identical_constraints_2838", "All declarations of '{0}' must have identical constraints."),
+        This_condition_will_always_return_0_since_JavaScript_compares_objects_by_reference_not_value: diag(2839, ts.DiagnosticCategory.Error, "This_condition_will_always_return_0_since_JavaScript_compares_objects_by_reference_not_value_2839", "This condition will always return '{0}' since JavaScript compares objects by reference, not value."),
         Import_declaration_0_is_using_private_name_1: diag(4000, ts.DiagnosticCategory.Error, "Import_declaration_0_is_using_private_name_1_4000", "Import declaration '{0}' is using private name '{1}'."),
         Type_parameter_0_of_exported_class_has_or_is_using_private_name_1: diag(4002, ts.DiagnosticCategory.Error, "Type_parameter_0_of_exported_class_has_or_is_using_private_name_1_4002", "Type parameter '{0}' of exported class has or is using private name '{1}'."),
         Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1: diag(4004, ts.DiagnosticCategory.Error, "Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1_4004", "Type parameter '{0}' of exported interface has or is using private name '{1}'."),
@@ -13205,6 +13206,19 @@ var ts;
         return isLiteralKind(node.kind);
     }
     ts.isLiteralExpression = isLiteralExpression;
+    /** @internal */
+    function isLiteralExpressionOfObject(node) {
+        switch (node.kind) {
+            case 205 /* ObjectLiteralExpression */:
+            case 204 /* ArrayLiteralExpression */:
+            case 13 /* RegularExpressionLiteral */:
+            case 213 /* FunctionExpression */:
+            case 226 /* ClassExpression */:
+                return true;
+        }
+        return false;
+    }
+    ts.isLiteralExpressionOfObject = isLiteralExpressionOfObject;
     // Pseudo-literals
     /* @internal */
     function isTemplateLiteralKind(kind) {
@@ -65371,18 +65385,6 @@ var ts;
                 }
                 return result;
             }
-            function removeIntersectionMembersWithoutKeys(type) {
-                if (!(type.flags & 2097152 /* Intersection */)) {
-                    return type;
-                }
-                return getIntersectionType(ts.filter(type.types, function (t) { return !isKeylessType(t); }));
-            }
-            function isKeylessType(type) {
-                return !!(getIndexType(type).flags & 131072 /* Never */);
-            }
-            function isConditionalFilteringKeylessTypes(type) {
-                return !!(type.flags & 16777216 /* Conditional */) && type.root.isDistributive && everyType(type.extendsType, isKeylessType);
-            }
             function structuredTypeRelatedTo(source, target, reportErrors, intersectionState) {
                 if (intersectionState & 4 /* PropertyCheck */) {
                     return propertiesRelatedTo(source, target, reportErrors, /*excludedProperties*/ undefined, 0 /* None */);
@@ -65521,34 +65523,9 @@ var ts;
                     var targetType_1 = target.type;
                     // A keyof S is related to a keyof T if T is related to S.
                     if (sourceFlags & 4194304 /* Index */) {
-                        var sourceType = source.type;
-                        if (result = isRelatedTo(targetType_1, sourceType, 3 /* Both */, /*reportErrors*/ false)) {
+                        if (result = isRelatedTo(targetType_1, source.type, 3 /* Both */, /*reportErrors*/ false)) {
                             return result;
                         }
-                        // If the source is a filtering conditional that removes only keyless sources, eg, `NonNullable<T>`,
-                        // then it doesn't affect the `keyof` query, and we can unwrap the conditional and relate the unwrapped source and target.
-                        // There may be multiple stacked conditionals, such as `T extends null ? never : T extends undefined ? never : T : T`, so
-                        // we need to repeat the unwrapping process.
-                        while (isConditionalFilteringKeylessTypes(sourceType)) {
-                            var lastSource = sourceType;
-                            sourceType = getDefaultConstraintOfConditionalType(sourceType);
-                            if (sourceType === lastSource) {
-                                break;
-                            }
-                            if (result = isRelatedTo(targetType_1, sourceType, 3 /* Both */, /*reportErrors*/ false)) {
-                                return result;
-                            }
-                            var simplifiedSource = sourceType;
-                            // In addition, `keyof (T & U)` is equivalent to `keyof T | keyof U`, so if `keyof U` is always `never`, we can omit
-                            // it from the relationship. This allows, eg, `keyof (T & object)` to be related to `keyof T`.
-                            sourceType = removeIntersectionMembersWithoutKeys(sourceType);
-                            if (sourceType === simplifiedSource) {
-                                continue;
-                            }
-                            if (result = isRelatedTo(targetType_1, sourceType, 3 /* Both */, /*reportErrors*/ false)) {
-                                return result;
-                            }
-                        }
                     }
                     if (isTupleType(targetType_1)) {
                         // An index type can have a tuple type target when the tuple type contains variadic elements.
@@ -67348,11 +67325,15 @@ var ts;
                 type.flags & 1048576 /* Union */ ? mapType(type, getWidenedUniqueESSymbolType) :
                     type;
         }
-        function getWidenedLiteralLikeTypeForContextualType(type, contextualType) {
-            if (!isLiteralOfContextualType(type, contextualType)) {
-                type = getWidenedUniqueESSymbolType(getWidenedLiteralType(type));
+        function getWidenedLiteralLikeTypeForContextualType(type, contextualType, node) {
+            if (isLiteralOfContextualType(type, contextualType)) {
+                return type;
             }
-            return type;
+            var instantiatedContextualType = node && instantiateContextualType(contextualType, node) || contextualType;
+            if (instantiatedContextualType !== contextualType && isLiteralOfContextualType(type, instantiatedContextualType)) {
+                return type;
+            }
+            return getWidenedUniqueESSymbolType(getWidenedLiteralType(type));
         }
         function getWidenedLiteralLikeTypeForContextualReturnTypeIfNeeded(type, contextualSignatureReturnType, isAsync) {
             if (type && isUnitType(type)) {
@@ -67422,24 +67403,16 @@ var ts;
             }
             return result;
         }
-        function getApparentIntersectionTypes(type) {
-            var apparent = getApparentType(type);
-            if (apparent.flags & 2097152 /* Intersection */) {
-                return apparent.types;
-            }
-            return [apparent];
-        }
         // Returns the String, Number, Boolean, StringLiteral, NumberLiteral, BooleanLiteral, Void, Undefined, or Null
         // flags for the string, number, boolean, "", 0, false, void, undefined, or null types respectively. Returns
         // no flags for all other types (including non-falsy literal types).
         function getFalsyFlags(type) {
             return type.flags & 1048576 /* Union */ ? getFalsyFlagsOfTypes(type.types) :
-                type.flags & 2097152 /* Intersection */ ? ts.reduceLeft(getApparentIntersectionTypes(type), function (memo, type) { return memo | getFalsyFlags(type); }, 0) :
-                    type.flags & 128 /* StringLiteral */ ? type.value === "" ? 128 /* StringLiteral */ : 0 :
-                        type.flags & 256 /* NumberLiteral */ ? type.value === 0 ? 256 /* NumberLiteral */ : 0 :
-                            type.flags & 2048 /* BigIntLiteral */ ? isZeroBigInt(type) ? 2048 /* BigIntLiteral */ : 0 :
-                                type.flags & 512 /* BooleanLiteral */ ? (type === falseType || type === regularFalseType) ? 512 /* BooleanLiteral */ : 0 :
-                                    type.flags & 117724 /* PossiblyFalsy */;
+                type.flags & 128 /* StringLiteral */ ? type.value === "" ? 128 /* StringLiteral */ : 0 :
+                    type.flags & 256 /* NumberLiteral */ ? type.value === 0 ? 256 /* NumberLiteral */ : 0 :
+                        type.flags & 2048 /* BigIntLiteral */ ? isZeroBigInt(type) ? 2048 /* BigIntLiteral */ : 0 :
+                            type.flags & 512 /* BooleanLiteral */ ? (type === falseType || type === regularFalseType) ? 512 /* BooleanLiteral */ : 0 :
+                                type.flags & 117724 /* PossiblyFalsy */;
         }
         function removeDefinitelyFalsyTypes(type) {
             return getFalsyFlags(type) & 117632 /* DefinitelyFalsy */ ?
@@ -70948,9 +70921,7 @@ var ts;
                     case "function":
                         return type.flags & 1 /* Any */ ? type : globalFunctionType;
                     case "object":
-                        var isUnknownish = type.flags & 2 /* Unknown */ ||
-                            (type.flags & 58982400 /* InstantiableNonPrimitive */ && (getBaseConstraintOfType(type) || unknownType).flags & 2 /* Unknown */);
-                        return isUnknownish ? getUnionType([nonPrimitiveType, nullType]) : type;
+                        return type.flags & 2 /* Unknown */ ? getUnionType([nonPrimitiveType, nullType]) : type;
                     default:
                         return typeofTypesByName.get(text);
                 }
@@ -72795,22 +72766,22 @@ var ts;
                 var inferenceContext = getInferenceContext(node);
                 // If no inferences have been made, nothing is gained from instantiating as type parameters
                 // would just be replaced with their defaults similar to the apparent type.
-                if (inferenceContext && ts.some(inferenceContext.inferences, hasInferenceCandidates)) {
+                if (inferenceContext && contextFlags & 1 /* Signature */ && (inferenceContext.returnMapper || ts.some(inferenceContext.inferences, hasInferenceCandidates))) {
                     // For contextual signatures we incorporate all inferences made so far, e.g. from return
                     // types as well as arguments to the left in a function call.
-                    if (contextFlags && contextFlags & 1 /* Signature */) {
-                        return instantiateInstantiableTypes(contextualType, inferenceContext.nonFixingMapper);
-                    }
+                    return instantiateInstantiableTypes(contextualType, inferenceContext.returnMapper
+                        ? combineTypeMappers(inferenceContext.nonFixingMapper, inferenceContext.returnMapper)
+                        : inferenceContext.nonFixingMapper);
+                }
+                if (inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.returnMapper) {
                     // For other purposes (e.g. determining whether to produce literal types) we only
                     // incorporate inferences made from the return type in a function call. We remove
                     // the 'boolean' type from the contextual type such that contextually typed boolean
                     // literals actually end up widening to 'boolean' (see #48363).
-                    if (inferenceContext.returnMapper) {
-                        var type = instantiateInstantiableTypes(contextualType, inferenceContext.returnMapper);
-                        return type.flags & 1048576 /* Union */ && containsType(type.types, regularFalseType) && containsType(type.types, regularTrueType) ?
-                            filterType(type, function (t) { return t !== regularFalseType && t !== regularTrueType; }) :
-                            type;
-                    }
+                    var type = instantiateInstantiableTypes(contextualType, inferenceContext.returnMapper);
+                    return type.flags & 1048576 /* Union */ && containsType(type.types, regularFalseType) && containsType(type.types, regularTrueType) ?
+                        filterType(type, function (t) { return t !== regularFalseType && t !== regularTrueType; }) :
+                        type;
                 }
             }
             return contextualType;
@@ -75344,29 +75315,43 @@ var ts;
             // 'let f: (x: string) => number = wrap(s => s.length)', we infer from the declared type of 'f' to the
             // return type of 'wrap'.
             if (node.kind !== 165 /* Decorator */) {
-                var contextualType = getContextualType(node, ts.every(signature.typeParameters, function (p) { return !!getDefaultFromTypeParameter(p); }) ? 8 /* SkipBindingPatterns */ : 0 /* None */);
+                var skipBindingPatterns = ts.every(signature.typeParameters, function (p) { return !!getDefaultFromTypeParameter(p); });
+                var contextualType = getContextualType(node, skipBindingPatterns ? 8 /* SkipBindingPatterns */ : 0 /* None */);
                 if (contextualType) {
                     var inferenceTargetType = getReturnTypeOfSignature(signature);
                     if (couldContainTypeVariables(inferenceTargetType)) {
-                        // We clone the inference context to avoid disturbing a resolution in progress for an
-                        // outer call expression. Effectively we just want a snapshot of whatever has been
-                        // inferred for any outer call expression so far.
                         var outerContext = getInferenceContext(node);
-                        var outerMapper = getMapperFromContext(cloneInferenceContext(outerContext, 1 /* NoDefault */));
-                        var instantiatedType = instantiateType(contextualType, outerMapper);
-                        // If the contextual type is a generic function type with a single call signature, we
-                        // instantiate the type with its own type parameters and type arguments. This ensures that
-                        // the type parameters are not erased to type any during type inference such that they can
-                        // be inferred as actual types from the contextual type. For example:
-                        //   declare function arrayMap<T, U>(f: (x: T) => U): (a: T[]) => U[];
-                        //   const boxElements: <A>(a: A[]) => { value: A }[] = arrayMap(value => ({ value }));
-                        // Above, the type of the 'value' parameter is inferred to be 'A'.
-                        var contextualSignature = getSingleCallSignature(instantiatedType);
-                        var inferenceSourceType = contextualSignature && contextualSignature.typeParameters ?
-                            getOrCreateTypeFromSignature(getSignatureInstantiationWithoutFillingInTypeArguments(contextualSignature, contextualSignature.typeParameters)) :
-                            instantiatedType;
-                        // Inferences made from return types have lower priority than all other inferences.
-                        inferTypes(context.inferences, inferenceSourceType, inferenceTargetType, 128 /* ReturnType */);
+                        var isFromBindingPattern = !skipBindingPatterns && getContextualType(node, 8 /* SkipBindingPatterns */) !== contextualType;
+                        // A return type inference from a binding pattern can be used in instantiating the contextual
+                        // type of an argument later in inference, but cannot stand on its own as the final return type.
+                        // It is incorporated into `context.returnMapper` which is used in `instantiateContextualType`,
+                        // but doesn't need to go into `context.inferences`. This allows a an array binding pattern to
+                        // produce a tuple for `T` in
+                        //   declare function f<T>(cb: () => T): T;
+                        //   const [e1, e2, e3] = f(() => [1, "hi", true]);
+                        // but does not produce any inference for `T` in
+                        //   declare function f<T>(): T;
+                        //   const [e1, e2, e3] = f();
+                        if (!isFromBindingPattern) {
+                            // We clone the inference context to avoid disturbing a resolution in progress for an
+                            // outer call expression. Effectively we just want a snapshot of whatever has been
+                            // inferred for any outer call expression so far.
+                            var outerMapper = getMapperFromContext(cloneInferenceContext(outerContext, 1 /* NoDefault */));
+                            var instantiatedType = instantiateType(contextualType, outerMapper);
+                            // If the contextual type is a generic function type with a single call signature, we
+                            // instantiate the type with its own type parameters and type arguments. This ensures that
+                            // the type parameters are not erased to type any during type inference such that they can
+                            // be inferred as actual types from the contextual type. For example:
+                            //   declare function arrayMap<T, U>(f: (x: T) => U): (a: T[]) => U[];
+                            //   const boxElements: <A>(a: A[]) => { value: A }[] = arrayMap(value => ({ value }));
+                            // Above, the type of the 'value' parameter is inferred to be 'A'.
+                            var contextualSignature = getSingleCallSignature(instantiatedType);
+                            var inferenceSourceType = contextualSignature && contextualSignature.typeParameters ?
+                                getOrCreateTypeFromSignature(getSignatureInstantiationWithoutFillingInTypeArguments(contextualSignature, contextualSignature.typeParameters)) :
+                                instantiatedType;
+                            // Inferences made from return types have lower priority than all other inferences.
+                            inferTypes(context.inferences, inferenceSourceType, inferenceTargetType, 128 /* ReturnType */);
+                        }
                         // Create a type mapper for instantiating generic contextual types using the inferences made
                         // from the return type. We need a separate inference pass here because (a) instantiation of
                         // the source type uses the outer context's return mapper (which excludes inferences made from
@@ -79024,6 +79009,10 @@ var ts;
                 case 35 /* ExclamationEqualsToken */:
                 case 36 /* EqualsEqualsEqualsToken */:
                 case 37 /* ExclamationEqualsEqualsToken */:
+                    if (ts.isLiteralExpressionOfObject(left) || ts.isLiteralExpressionOfObject(right)) {
+                        var eqType = operator === 34 /* EqualsEqualsToken */ || operator === 36 /* EqualsEqualsEqualsToken */;
+                        error(errorNode, ts.Diagnostics.This_condition_will_always_return_0_since_JavaScript_compares_objects_by_reference_not_value, eqType ? "false" : "true");
+                    }
                     reportOperatorErrorUnless(function (left, right) { return isTypeEqualityComparableTo(left, right) || isTypeEqualityComparableTo(right, left); });
                     return booleanType;
                 case 102 /* InstanceOfKeyword */:
@@ -79479,7 +79468,7 @@ var ts;
             var type = checkExpression(node, checkMode, forceTuple);
             return isConstContext(node) || ts.isCommonJsExportedExpression(node) ? getRegularTypeOfLiteralType(type) :
                 isTypeAssertion(node) ? type :
-                    getWidenedLiteralLikeTypeForContextualType(type, instantiateContextualType(arguments.length === 2 ? getContextualType(node) : contextualType, node));
+                    getWidenedLiteralLikeTypeForContextualType(type, arguments.length === 2 ? getContextualType(node) : contextualType, node);
         }
         function checkPropertyAssignment(node, checkMode) {
             // Do not use hasDynamicName here, because that returns false for well known symbols.