typescript 4.8.0-dev.20220713 → 4.8.0-dev.20220716

package/lib/lib.es2015.collection.d.ts

@@ -19,18 +19,38 @@ and limitations under the License.
 
 
 interface Map<K, V> {
+
     clear(): void;
+    /**
+     * @returns true if an element in the Map existed and has been removed, or false if the element does not exist.
+     */
     delete(key: K): boolean;
+    /**
+     * Executes a provided function once per each key/value pair in the Map, in insertion order.
+     */
     forEach(callbackfn: (value: V, key: K, map: Map<K, V>) => void, thisArg?: any): void;
+    /**
+     * Returns a specified element from the Map object. If the value that is associated to the provided key is an object, then you will get a reference to that object and any change made to that object will effectively modify it inside the Map.
+     * @returns Returns the element associated with the specified key. If no element is associated with the specified key, undefined is returned.
+     */
     get(key: K): V | undefined;
+    /**
+     * @returns boolean indicating whether an element with the specified key exists or not.
+     */
     has(key: K): boolean;
+    /**
+     * Adds a new element with a specified key and value to the Map. If an element with the same key already exists, the element will be updated.
+     */
     set(key: K, value: V): this;
+    /**
+     * @returns the number of elements in the Map.
+     */
     readonly size: number;
 }
 
 interface MapConstructor {
     new(): Map<any, any>;
-    new<K, V>(entries?: readonly (readonly [K, V])[] | null): Map<K, V>;
+    new <K, V>(entries?: readonly (readonly [K, V])[] | null): Map<K, V>;
     readonly prototype: Map<any, any>;
 }
 declare var Map: MapConstructor;
@@ -43,9 +63,23 @@ interface ReadonlyMap<K, V> {
 }
 
 interface WeakMap<K extends object, V> {
+    /**
+     * Removes the specified element from the WeakMap.
+     * @returns true if the element was successfully removed, or false if it was not present.
+     */
     delete(key: K): boolean;
+    /**
+     * @returns a specified element.
+     */
     get(key: K): V | undefined;
+    /**
+     * @returns a boolean indicating whether an element with the specified key exists or not.
+     */
     has(key: K): boolean;
+    /**
+     * Adds a new element with a specified key and value.
+     * @param key Must be an object.
+     */
     set(key: K, value: V): this;
 }
 
@@ -56,11 +90,28 @@ interface WeakMapConstructor {
 declare var WeakMap: WeakMapConstructor;
 
 interface Set<T> {
+    /**
+     * Appends a new element with a specified value to the end of the Set.
+     */
     add(value: T): this;
+
     clear(): void;
+    /**
+     * Removes a specified value from the Set.
+     * @returns Returns true if an element in the Set existed and has been removed, or false if the element does not exist.
+     */
     delete(value: T): boolean;
+    /**
+     * Executes a provided function once per each value in the Set object, in insertion order.
+     */
     forEach(callbackfn: (value: T, value2: T, set: Set<T>) => void, thisArg?: any): void;
+    /**
+     * @returns a boolean indicating whether an element with the specified value exists in the Set or not.
+     */
     has(value: T): boolean;
+    /**
+     * @returns the number of (unique) elements in Set.
+     */
     readonly size: number;
 }
 
@@ -77,8 +128,18 @@ interface ReadonlySet<T> {
 }
 
 interface WeakSet<T extends object> {
+    /**
+     * Appends a new object to the end of the WeakSet.
+     */
     add(value: T): this;
+    /**
+     * Removes the specified element from the WeakSet.
+     * @returns Returns true if the element existed and has been removed, or false if the element does not exist.
+     */
     delete(value: T): boolean;
+    /**
+     * @returns a boolean indicating whether an object exists in the WeakSet or not.
+     */
     has(value: T): boolean;
 }
 

package/lib/tsc.js

@@ -69,7 +69,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 var ts;
 (function (ts) {
     ts.versionMajorMinor = "4.8";
-    ts.version = ts.versionMajorMinor + ".0-dev.20220713";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220716";
     var NativeCollections;
     (function (NativeCollections) {
         var globals = typeof globalThis !== "undefined" ? globalThis :
@@ -38457,24 +38457,6 @@ var ts;
             typeLiteralSymbol.members.set(symbol.escapedName, symbol);
         }
         function bindObjectLiteralExpression(node) {
-            if (inStrictMode && !ts.isAssignmentTarget(node)) {
-                var seen = new ts.Map();
-                for (var _i = 0, _a = node.properties; _i < _a.length; _i++) {
-                    var prop = _a[_i];
-                    if (prop.kind === 298 || prop.name.kind !== 79) {
-                        continue;
-                    }
-                    var identifier = prop.name;
-                    var currentKind = prop.kind === 296 || prop.kind === 297 || prop.kind === 169
-                        ? 1
-                        : 2;
-                    var existingKind = seen.get(identifier.escapedText);
-                    if (!existingKind) {
-                        seen.set(identifier.escapedText, currentKind);
-                        continue;
-                    }
-                }
-            }
             return bindAnonymousDeclaration(node, 4096, "__object");
         }
         function bindJsxAttributes(node) {
@@ -40278,11 +40260,10 @@ var ts;
         var unresolvedSymbols = new ts.Map();
         var errorTypes = new ts.Map();
         var anyType = createIntrinsicType(1, "any");
-        var autoType = createIntrinsicType(1, "any");
+        var autoType = createIntrinsicType(1, "any", 262144);
         var wildcardType = createIntrinsicType(1, "any");
         var errorType = createIntrinsicType(1, "error");
         var unresolvedType = createIntrinsicType(1, "unresolved");
-        var nonInferrableAnyType = createIntrinsicType(1, "any", 65536);
         var intrinsicMarkerType = createIntrinsicType(1, "intrinsic");
         var unknownType = createIntrinsicType(2, "unknown");
         var nonNullUnknownType = createIntrinsicType(2, "unknown");
@@ -40311,8 +40292,7 @@ var ts;
         var esSymbolType = createIntrinsicType(4096, "symbol");
         var voidType = createIntrinsicType(16384, "void");
         var neverType = createIntrinsicType(131072, "never");
-        var silentNeverType = createIntrinsicType(131072, "never");
-        var nonInferrableType = createIntrinsicType(131072, "never", 262144);
+        var silentNeverType = createIntrinsicType(131072, "never", 262144);
         var implicitNeverType = createIntrinsicType(131072, "never");
         var unreachableNeverType = createIntrinsicType(131072, "never");
         var nonPrimitiveType = createIntrinsicType(67108864, "object");
@@ -47043,7 +47023,7 @@ var ts;
             if (reportErrors && !declarationBelongsToPrivateAmbientMember(element)) {
                 reportImplicitAny(element, anyType);
             }
-            return includePatternInType ? nonInferrableAnyType : anyType;
+            return anyType;
         }
         function getTypeFromObjectBindingPattern(pattern, includePatternInType, reportErrors) {
             var members = ts.createSymbolTable();
@@ -50345,7 +50325,7 @@ var ts;
             var result = 0;
             for (var _i = 0, types_8 = types; _i < types_8.length; _i++) {
                 var type = types_8[_i];
-                if (!(type.flags & excludeKinds)) {
+                if (excludeKinds === undefined || !(type.flags & excludeKinds)) {
                     result |= ts.getObjectFlags(type);
                 }
             }
@@ -50357,7 +50337,7 @@ var ts;
             if (!type) {
                 type = createObjectType(4, target.symbol);
                 target.instantiations.set(id, type);
-                type.objectFlags |= typeArguments ? getPropagatingFlagsOfTypes(typeArguments, 0) : 0;
+                type.objectFlags |= typeArguments ? getPropagatingFlagsOfTypes(typeArguments) : 0;
                 type.target = target;
                 type.resolvedTypeArguments = typeArguments;
             }
@@ -53417,6 +53397,7 @@ var ts;
             result.mapper = mapper;
             result.aliasSymbol = aliasSymbol || type.aliasSymbol;
             result.aliasTypeArguments = aliasSymbol ? aliasTypeArguments : instantiateTypes(type.aliasTypeArguments, mapper);
+            result.objectFlags |= result.aliasTypeArguments ? getPropagatingFlagsOfTypes(result.aliasTypeArguments) : 0;
             return result;
         }
         function getConditionalTypeInstantiation(type, mapper, aliasSymbol, aliasTypeArguments) {
@@ -57685,8 +57666,10 @@ var ts;
                     propagationType = savePropagationType;
                     return;
                 }
-                if (source.aliasSymbol && source.aliasTypeArguments && source.aliasSymbol === target.aliasSymbol) {
-                    inferFromTypeArguments(source.aliasTypeArguments, target.aliasTypeArguments, getAliasVariances(source.aliasSymbol));
+                if (source.aliasSymbol && source.aliasSymbol === target.aliasSymbol) {
+                    if (source.aliasTypeArguments) {
+                        inferFromTypeArguments(source.aliasTypeArguments, target.aliasTypeArguments, getAliasVariances(source.aliasSymbol));
+                    }
                     return;
                 }
                 if (source === target && source.flags & 3145728) {
@@ -57723,7 +57706,7 @@ var ts;
                     target = getActualTypeVariable(target);
                 }
                 if (target.flags & 8650752) {
-                    if (source === nonInferrableAnyType || source === silentNeverType || (priority & 128 && (source === autoType || source === autoArrayType)) || isFromInferenceBlockedSource(source)) {
+                    if (isFromInferenceBlockedSource(source)) {
                         return;
                     }
                     var inference = getInferenceInfoForType(target);
@@ -58192,19 +58175,16 @@ var ts;
                 var sourceLen = sourceSignatures.length;
                 var targetLen = targetSignatures.length;
                 var len = sourceLen < targetLen ? sourceLen : targetLen;
-                var skipParameters = !!(ts.getObjectFlags(source) & 262144);
                 for (var i = 0; i < len; i++) {
-                    inferFromSignature(getBaseSignature(sourceSignatures[sourceLen - len + i]), getErasedSignature(targetSignatures[targetLen - len + i]), skipParameters);
+                    inferFromSignature(getBaseSignature(sourceSignatures[sourceLen - len + i]), getErasedSignature(targetSignatures[targetLen - len + i]));
                 }
             }
-            function inferFromSignature(source, target, skipParameters) {
-                if (!skipParameters) {
-                    var saveBivariant = bivariant;
-                    var kind = target.declaration ? target.declaration.kind : 0;
-                    bivariant = bivariant || kind === 169 || kind === 168 || kind === 171;
-                    applyToParameterTypes(source, target, inferFromContravariantTypes);
-                    bivariant = saveBivariant;
-                }
+            function inferFromSignature(source, target) {
+                var saveBivariant = bivariant;
+                var kind = target.declaration ? target.declaration.kind : 0;
+                bivariant = bivariant || kind === 169 || kind === 168 || kind === 171;
+                applyToParameterTypes(source, target, inferFromContravariantTypes);
+                bivariant = saveBivariant;
                 applyToReturnTypes(source, target, inferFromTypes);
             }
             function inferFromIndexTypes(source, target) {
@@ -60178,16 +60158,23 @@ var ts;
                 if (!assumeTrue) {
                     return filterType(type, function (t) { return !isRelated(t, candidate); });
                 }
-                if (type.flags & 1048576) {
-                    var assignableType = filterType(type, function (t) { return isRelated(t, candidate); });
-                    if (!(assignableType.flags & 131072)) {
-                        return assignableType;
-                    }
+                if (type.flags & 3) {
+                    return candidate;
                 }
-                return isTypeSubtypeOf(candidate, type) ? candidate :
-                    isTypeAssignableTo(type, candidate) ? type :
-                        isTypeAssignableTo(candidate, type) ? candidate :
-                            getIntersectionType([type, candidate]);
+                var keyPropertyName = type.flags & 1048576 ? getKeyPropertyName(type) : undefined;
+                var narrowedType = mapType(candidate, function (c) {
+                    var discriminant = keyPropertyName && getTypeOfPropertyOfType(c, keyPropertyName);
+                    var matching = discriminant && getConstituentTypeForKeyType(type, discriminant);
+                    var directlyRelated = mapType(matching || type, function (t) { return isRelated(t, c) ? t : isRelated(c, t) ? c : neverType; });
+                    return directlyRelated.flags & 131072 ?
+                        mapType(type, function (t) { return maybeTypeOfKind(t, 465829888) && isRelated(c, getBaseConstraintOfType(t) || unknownType) ? getIntersectionType([t, c]) : neverType; }) :
+                        directlyRelated;
+                });
+                return !(narrowedType.flags & 131072) ? narrowedType :
+                    isTypeSubtypeOf(candidate, type) ? candidate :
+                        isTypeAssignableTo(type, candidate) ? type :
+                            isTypeAssignableTo(candidate, type) ? candidate :
+                                getIntersectionType([type, candidate]);
             }
             function narrowTypeByCallExpression(type, callExpression, assumeTrue) {
                 if (hasMatchingArgument(callExpression, reference)) {
@@ -61287,6 +61274,14 @@ var ts;
                 var lhsType = getTypeOfExpression(e.expression);
                 return ts.isPrivateIdentifier(e.name) ? tryGetPrivateIdentifierPropertyOfType(lhsType, e.name) : getPropertyOfType(lhsType, e.name.escapedText);
             }
+            if (ts.isElementAccessExpression(e)) {
+                var propType = checkExpressionCached(e.argumentExpression);
+                if (!isTypeUsableAsPropertyName(propType)) {
+                    return undefined;
+                }
+                var lhsType = getTypeOfExpression(e.expression);
+                return getPropertyOfType(lhsType, getPropertyNameFromType(propType));
+            }
             return undefined;
             function tryGetPrivateIdentifierPropertyOfType(type, id) {
                 var lexicallyScopedSymbol = lookupSymbolForPrivateIdentifierDeclaration(id.escapedText, id);
@@ -65063,7 +65058,7 @@ var ts;
             checkGrammarTypeArguments(node, node.typeArguments);
             var signature = getResolvedSignature(node, undefined, checkMode);
             if (signature === resolvingSignature) {
-                return nonInferrableType;
+                return silentNeverType;
             }
             checkDeprecatedSignature(signature, node);
             if (node.expression.kind === 106) {
@@ -70743,9 +70738,14 @@ var ts;
         function unwrapReturnType(returnType, functionFlags) {
             var isGenerator = !!(functionFlags & 1);
             var isAsync = !!(functionFlags & 2);
-            return isGenerator ? getIterationTypeOfGeneratorFunctionReturnType(1, returnType, isAsync) || errorType :
-                isAsync ? getAwaitedTypeNoAlias(returnType) || errorType :
-                    returnType;
+            if (isGenerator) {
+                var returnIterationType = getIterationTypeOfGeneratorFunctionReturnType(1, returnType, isAsync);
+                if (!returnIterationType) {
+                    return errorType;
+                }
+                return isAsync ? getAwaitedTypeNoAlias(unwrapAwaitedType(returnIterationType)) : returnIterationType;
+            }
+            return isAsync ? getAwaitedTypeNoAlias(returnType) || errorType : returnType;
         }
         function isUnwrappedReturnTypeVoidOrAny(func, returnType) {
             var unwrappedReturnType = unwrapReturnType(returnType, ts.getFunctionFlags(func));

package/lib/tsserver.js

@@ -109,7 +109,7 @@ var ts;
     // The following is baselined as a literal template type without intervention
     /** The version of the TypeScript compiler release */
     // eslint-disable-next-line @typescript-eslint/no-inferrable-types
-    ts.version = ts.versionMajorMinor + ".0-dev.20220713";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220716";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -46881,37 +46881,6 @@ var ts;
             typeLiteralSymbol.members.set(symbol.escapedName, symbol);
         }
         function bindObjectLiteralExpression(node) {
-            var ElementKind;
-            (function (ElementKind) {
-                ElementKind[ElementKind["Property"] = 1] = "Property";
-                ElementKind[ElementKind["Accessor"] = 2] = "Accessor";
-            })(ElementKind || (ElementKind = {}));
-            if (inStrictMode && !ts.isAssignmentTarget(node)) {
-                var seen = new ts.Map();
-                for (var _i = 0, _a = node.properties; _i < _a.length; _i++) {
-                    var prop = _a[_i];
-                    if (prop.kind === 298 /* SpreadAssignment */ || prop.name.kind !== 79 /* Identifier */) {
-                        continue;
-                    }
-                    var identifier = prop.name;
-                    // ECMA-262 11.1.5 Object Initializer
-                    // If previous is not undefined then throw a SyntaxError exception if any of the following conditions are true
-                    // a.This production is contained in strict code and IsDataDescriptor(previous) is true and
-                    // IsDataDescriptor(propId.descriptor) is true.
-                    //    b.IsDataDescriptor(previous) is true and IsAccessorDescriptor(propId.descriptor) is true.
-                    //    c.IsAccessorDescriptor(previous) is true and IsDataDescriptor(propId.descriptor) is true.
-                    //    d.IsAccessorDescriptor(previous) is true and IsAccessorDescriptor(propId.descriptor) is true
-                    // and either both previous and propId.descriptor have[[Get]] fields or both previous and propId.descriptor have[[Set]] fields
-                    var currentKind = prop.kind === 296 /* PropertyAssignment */ || prop.kind === 297 /* ShorthandPropertyAssignment */ || prop.kind === 169 /* MethodDeclaration */
-                        ? 1 /* Property */
-                        : 2 /* Accessor */;
-                    var existingKind = seen.get(identifier.escapedText);
-                    if (!existingKind) {
-                        seen.set(identifier.escapedText, currentKind);
-                        continue;
-                    }
-                }
-            }
             return bindAnonymousDeclaration(node, 4096 /* ObjectLiteral */, "__object" /* Object */);
         }
         function bindJsxAttributes(node) {
@@ -49150,11 +49119,10 @@ var ts;
         var unresolvedSymbols = new ts.Map();
         var errorTypes = new ts.Map();
         var anyType = createIntrinsicType(1 /* Any */, "any");
-        var autoType = createIntrinsicType(1 /* Any */, "any");
+        var autoType = createIntrinsicType(1 /* Any */, "any", 262144 /* NonInferrableType */);
         var wildcardType = createIntrinsicType(1 /* Any */, "any");
         var errorType = createIntrinsicType(1 /* Any */, "error");
         var unresolvedType = createIntrinsicType(1 /* Any */, "unresolved");
-        var nonInferrableAnyType = createIntrinsicType(1 /* Any */, "any", 65536 /* ContainsWideningType */);
         var intrinsicMarkerType = createIntrinsicType(1 /* Any */, "intrinsic");
         var unknownType = createIntrinsicType(2 /* Unknown */, "unknown");
         var nonNullUnknownType = createIntrinsicType(2 /* Unknown */, "unknown");
@@ -49183,8 +49151,7 @@ var ts;
         var esSymbolType = createIntrinsicType(4096 /* ESSymbol */, "symbol");
         var voidType = createIntrinsicType(16384 /* Void */, "void");
         var neverType = createIntrinsicType(131072 /* Never */, "never");
-        var silentNeverType = createIntrinsicType(131072 /* Never */, "never");
-        var nonInferrableType = createIntrinsicType(131072 /* Never */, "never", 262144 /* NonInferrableType */);
+        var silentNeverType = createIntrinsicType(131072 /* Never */, "never", 262144 /* NonInferrableType */);
         var implicitNeverType = createIntrinsicType(131072 /* Never */, "never");
         var unreachableNeverType = createIntrinsicType(131072 /* Never */, "never");
         var nonPrimitiveType = createIntrinsicType(67108864 /* NonPrimitive */, "object");
@@ -56922,11 +56889,7 @@ var ts;
             if (reportErrors && !declarationBelongsToPrivateAmbientMember(element)) {
                 reportImplicitAny(element, anyType);
             }
-            // When we're including the pattern in the type (an indication we're obtaining a contextual type), we
-            // use the non-inferrable any type. Inference will never directly infer this type, but it is possible
-            // to infer a type that contains it, e.g. for a binding pattern like [foo] or { foo }. In such cases,
-            // widening of the binding pattern type substitutes a regular any for the non-inferrable any.
-            return includePatternInType ? nonInferrableAnyType : anyType;
+            return anyType;
         }
         // Return the type implied by an object binding pattern
         function getTypeFromObjectBindingPattern(pattern, includePatternInType, reportErrors) {
@@ -60712,13 +60675,13 @@ var ts;
         }
         // This function is used to propagate certain flags when creating new object type references and union types.
         // It is only necessary to do so if a constituent type might be the undefined type, the null type, the type
-        // of an object literal or the anyFunctionType. This is because there are operations in the type checker
+        // of an object literal or a non-inferrable type. This is because there are operations in the type checker
         // that care about the presence of such types at arbitrary depth in a containing type.
         function getPropagatingFlagsOfTypes(types, excludeKinds) {
             var result = 0;
             for (var _i = 0, types_8 = types; _i < types_8.length; _i++) {
                 var type = types_8[_i];
-                if (!(type.flags & excludeKinds)) {
+                if (excludeKinds === undefined || !(type.flags & excludeKinds)) {
                     result |= ts.getObjectFlags(type);
                 }
             }
@@ -60730,7 +60693,7 @@ var ts;
             if (!type) {
                 type = createObjectType(4 /* Reference */, target.symbol);
                 target.instantiations.set(id, type);
-                type.objectFlags |= typeArguments ? getPropagatingFlagsOfTypes(typeArguments, /*excludeKinds*/ 0) : 0;
+                type.objectFlags |= typeArguments ? getPropagatingFlagsOfTypes(typeArguments) : 0;
                 type.target = target;
                 type.resolvedTypeArguments = typeArguments;
             }
@@ -64164,6 +64127,7 @@ var ts;
             result.mapper = mapper;
             result.aliasSymbol = aliasSymbol || type.aliasSymbol;
             result.aliasTypeArguments = aliasSymbol ? aliasTypeArguments : instantiateTypes(type.aliasTypeArguments, mapper);
+            result.objectFlags |= result.aliasTypeArguments ? getPropagatingFlagsOfTypes(result.aliasTypeArguments) : 0;
             return result;
         }
         function getConditionalTypeInstantiation(type, mapper, aliasSymbol, aliasTypeArguments) {
@@ -69116,10 +69080,13 @@ var ts;
                     propagationType = savePropagationType;
                     return;
                 }
-                if (source.aliasSymbol && source.aliasTypeArguments && source.aliasSymbol === target.aliasSymbol) {
-                    // Source and target are types originating in the same generic type alias declaration.
-                    // Simply infer from source type arguments to target type arguments.
-                    inferFromTypeArguments(source.aliasTypeArguments, target.aliasTypeArguments, getAliasVariances(source.aliasSymbol));
+                if (source.aliasSymbol && source.aliasSymbol === target.aliasSymbol) {
+                    if (source.aliasTypeArguments) {
+                        // Source and target are types originating in the same generic type alias declaration.
+                        // Simply infer from source type arguments to target type arguments.
+                        inferFromTypeArguments(source.aliasTypeArguments, target.aliasTypeArguments, getAliasVariances(source.aliasSymbol));
+                    }
+                    // And if there weren't any type arguments, there's no reason to run inference as the types must be the same.
                     return;
                 }
                 if (source === target && source.flags & 3145728 /* UnionOrIntersection */) {
@@ -69175,18 +69142,26 @@ var ts;
                     target = getActualTypeVariable(target);
                 }
                 if (target.flags & 8650752 /* TypeVariable */) {
-                    // If target is a type parameter, make an inference, unless the source type contains
-                    // the anyFunctionType (the wildcard type that's used to avoid contextually typing functions).
-                    // Because the anyFunctionType is internal, it should not be exposed to the user by adding
-                    // it as an inference candidate. Hopefully, a better candidate will come along that does
-                    // not contain anyFunctionType when we come back to this argument for its second round
-                    // of inference. Also, we exclude inferences for silentNeverType (which is used as a wildcard
-                    // when constructing types from type parameters that had no inference candidates).
-                    if (source === nonInferrableAnyType || source === silentNeverType || (priority & 128 /* ReturnType */ && (source === autoType || source === autoArrayType)) || isFromInferenceBlockedSource(source)) {
+                    // Skip inference if the source is "blocked", which is used by the language service to
+                    // prevent inference on nodes currently being edited.
+                    if (isFromInferenceBlockedSource(source)) {
                         return;
                     }
                     var inference = getInferenceInfoForType(target);
                     if (inference) {
+                        // If target is a type parameter, make an inference, unless the source type contains
+                        // a "non-inferrable" type. Types with this flag set are markers used to prevent inference.
+                        //
+                        // For example:
+                        //     - anyFunctionType is a wildcard type that's used to avoid contextually typing functions;
+                        //       it's internal, so should not be exposed to the user by adding it as a candidate.
+                        //     - autoType (and autoArrayType) is a special "any" used in control flow; like anyFunctionType,
+                        //       it's internal and should not be observable.
+                        //     - silentNeverType is returned by getInferredType when instantiating a generic function for
+                        //       inference (and a type variable has no mapping).
+                        //
+                        // This flag is infectious; if we produce Box<never> (where never is silentNeverType), Box<never> is
+                        // also non-inferrable.
                         if (ts.getObjectFlags(source) & 262144 /* NonInferrableType */) {
                             return;
                         }
@@ -69729,20 +69704,17 @@ var ts;
                 var sourceLen = sourceSignatures.length;
                 var targetLen = targetSignatures.length;
                 var len = sourceLen < targetLen ? sourceLen : targetLen;
-                var skipParameters = !!(ts.getObjectFlags(source) & 262144 /* NonInferrableType */);
                 for (var i = 0; i < len; i++) {
-                    inferFromSignature(getBaseSignature(sourceSignatures[sourceLen - len + i]), getErasedSignature(targetSignatures[targetLen - len + i]), skipParameters);
+                    inferFromSignature(getBaseSignature(sourceSignatures[sourceLen - len + i]), getErasedSignature(targetSignatures[targetLen - len + i]));
                 }
             }
-            function inferFromSignature(source, target, skipParameters) {
-                if (!skipParameters) {
-                    var saveBivariant = bivariant;
-                    var kind = target.declaration ? target.declaration.kind : 0 /* Unknown */;
-                    // Once we descend into a bivariant signature we remain bivariant for all nested inferences
-                    bivariant = bivariant || kind === 169 /* MethodDeclaration */ || kind === 168 /* MethodSignature */ || kind === 171 /* Constructor */;
-                    applyToParameterTypes(source, target, inferFromContravariantTypes);
-                    bivariant = saveBivariant;
-                }
+            function inferFromSignature(source, target) {
+                var saveBivariant = bivariant;
+                var kind = target.declaration ? target.declaration.kind : 0 /* Unknown */;
+                // Once we descend into a bivariant signature we remain bivariant for all nested inferences
+                bivariant = bivariant || kind === 169 /* MethodDeclaration */ || kind === 168 /* MethodSignature */ || kind === 171 /* Constructor */;
+                applyToParameterTypes(source, target, inferFromContravariantTypes);
+                bivariant = saveBivariant;
                 applyToReturnTypes(source, target, inferFromTypes);
             }
             function inferFromIndexTypes(source, target) {
@@ -71944,23 +71916,32 @@ var ts;
                 if (!assumeTrue) {
                     return filterType(type, function (t) { return !isRelated(t, candidate); });
                 }
-                // If the current type is a union type, remove all constituents that couldn't be instances of
-                // the candidate type. If one or more constituents remain, return a union of those.
-                if (type.flags & 1048576 /* Union */) {
-                    var assignableType = filterType(type, function (t) { return isRelated(t, candidate); });
-                    if (!(assignableType.flags & 131072 /* Never */)) {
-                        return assignableType;
-                    }
+                if (type.flags & 3 /* AnyOrUnknown */) {
+                    return candidate;
                 }
-                // If the candidate type is a subtype of the target type, narrow to the candidate type.
-                // Otherwise, if the target type is assignable to the candidate type, keep the target type.
-                // Otherwise, if the candidate type is assignable to the target type, narrow to the candidate
-                // type. Otherwise, the types are completely unrelated, so narrow to an intersection of the
-                // two types.
-                return isTypeSubtypeOf(candidate, type) ? candidate :
-                    isTypeAssignableTo(type, candidate) ? type :
-                        isTypeAssignableTo(candidate, type) ? candidate :
-                            getIntersectionType([type, candidate]);
+                // We first attempt to filter the current type, narrowing constituents as appropriate and removing
+                // constituents that are unrelated to the candidate.
+                var keyPropertyName = type.flags & 1048576 /* Union */ ? getKeyPropertyName(type) : undefined;
+                var narrowedType = mapType(candidate, function (c) {
+                    // If a discriminant property is available, use that to reduce the type.
+                    var discriminant = keyPropertyName && getTypeOfPropertyOfType(c, keyPropertyName);
+                    var matching = discriminant && getConstituentTypeForKeyType(type, discriminant);
+                    // For each constituent t in the current type, if t and and c are directly related, pick the most
+                    // specific of the two.
+                    var directlyRelated = mapType(matching || type, function (t) { return isRelated(t, c) ? t : isRelated(c, t) ? c : neverType; });
+                    // If no constituents are directly related, create intersections for any generic constituents that
+                    // are related by constraint.
+                    return directlyRelated.flags & 131072 /* Never */ ?
+                        mapType(type, function (t) { return maybeTypeOfKind(t, 465829888 /* Instantiable */) && isRelated(c, getBaseConstraintOfType(t) || unknownType) ? getIntersectionType([t, c]) : neverType; }) :
+                        directlyRelated;
+                });
+                // If filtering produced a non-empty type, return that. Otherwise, pick the most specific of the two
+                // based on assignability, or as a last resort produce an intersection.
+                return !(narrowedType.flags & 131072 /* Never */) ? narrowedType :
+                    isTypeSubtypeOf(candidate, type) ? candidate :
+                        isTypeAssignableTo(type, candidate) ? type :
+                            isTypeAssignableTo(candidate, type) ? candidate :
+                                getIntersectionType([type, candidate]);
             }
             function narrowTypeByCallExpression(type, callExpression, assumeTrue) {
                 if (hasMatchingArgument(callExpression, reference)) {
@@ -73326,6 +73307,14 @@ var ts;
                 var lhsType = getTypeOfExpression(e.expression);
                 return ts.isPrivateIdentifier(e.name) ? tryGetPrivateIdentifierPropertyOfType(lhsType, e.name) : getPropertyOfType(lhsType, e.name.escapedText);
             }
+            if (ts.isElementAccessExpression(e)) {
+                var propType = checkExpressionCached(e.argumentExpression);
+                if (!isTypeUsableAsPropertyName(propType)) {
+                    return undefined;
+                }
+                var lhsType = getTypeOfExpression(e.expression);
+                return getPropertyOfType(lhsType, getPropertyNameFromType(propType));
+            }
             return undefined;
             function tryGetPrivateIdentifierPropertyOfType(type, id) {
                 var lexicallyScopedSymbol = lookupSymbolForPrivateIdentifierDeclaration(id.escapedText, id);
@@ -77240,7 +77229,7 @@ var ts;
             // returns a function type, we choose to defer processing. This narrowly permits function composition
             // operators to flow inferences through return types, but otherwise processes calls right away. We
             // use the resolvingSignature singleton to indicate that we deferred processing. This result will be
-            // propagated out and eventually turned into nonInferrableType (a type that is assignable to anything and
+            // propagated out and eventually turned into silentNeverType (a type that is assignable to anything and
             // from which we never make inferences).
             if (checkMode & 8 /* SkipGenericFunctions */ && !node.typeArguments && callSignatures.some(isGenericFunctionReturningFunction)) {
                 skippedGenericFunction(node, checkMode);
@@ -77793,8 +77782,8 @@ var ts;
             var signature = getResolvedSignature(node, /*candidatesOutArray*/ undefined, checkMode);
             if (signature === resolvingSignature) {
                 // CheckMode.SkipGenericFunctions is enabled and this is a call to a generic function that
-                // returns a function type. We defer checking and return nonInferrableType.
-                return nonInferrableType;
+                // returns a function type. We defer checking and return silentNeverType.
+                return silentNeverType;
             }
             checkDeprecatedSignature(signature, node);
             if (node.expression.kind === 106 /* SuperKeyword */) {
@@ -84420,9 +84409,14 @@ var ts;
         function unwrapReturnType(returnType, functionFlags) {
             var isGenerator = !!(functionFlags & 1 /* Generator */);
             var isAsync = !!(functionFlags & 2 /* Async */);
-            return isGenerator ? getIterationTypeOfGeneratorFunctionReturnType(1 /* Return */, returnType, isAsync) || errorType :
-                isAsync ? getAwaitedTypeNoAlias(returnType) || errorType :
-                    returnType;
+            if (isGenerator) {
+                var returnIterationType = getIterationTypeOfGeneratorFunctionReturnType(1 /* Return */, returnType, isAsync);
+                if (!returnIterationType) {
+                    return errorType;
+                }
+                return isAsync ? getAwaitedTypeNoAlias(unwrapAwaitedType(returnIterationType)) : returnIterationType;
+            }
+            return isAsync ? getAwaitedTypeNoAlias(returnType) || errorType : returnType;
         }
         function isUnwrappedReturnTypeVoidOrAny(func, returnType) {
             var unwrappedReturnType = unwrapReturnType(returnType, ts.getFunctionFlags(func));