typescript 4.8.0-dev.20220714 → 4.8.0-dev.20220717

package/lib/typescriptServices.js

@@ -294,7 +294,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.20220714";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220717";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -47066,37 +47066,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) {
@@ -49335,11 +49304,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");
@@ -49368,8 +49336,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");
@@ -57107,11 +57074,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) {
@@ -60897,13 +60860,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);
                 }
             }
@@ -60915,7 +60878,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;
             }
@@ -64349,6 +64312,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) {
@@ -69301,10 +69265,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 */) {
@@ -69360,18 +69327,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;
                         }
@@ -69914,20 +69889,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) {
@@ -72129,23 +72101,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)) {
@@ -77433,7 +77414,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);
@@ -77986,8 +77967,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 */) {
@@ -84613,9 +84594,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));

package/lib/typingsInstaller.js

@@ -89,7 +89,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.20220714";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220717";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -46861,37 +46861,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) {
@@ -49130,11 +49099,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");
@@ -49163,8 +49131,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");
@@ -56902,11 +56869,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) {
@@ -60692,13 +60655,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);
                 }
             }
@@ -60710,7 +60673,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;
             }
@@ -64144,6 +64107,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) {
@@ -69096,10 +69060,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 */) {
@@ -69155,18 +69122,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;
                         }
@@ -69709,20 +69684,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) {
@@ -71924,23 +71896,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)) {
@@ -77228,7 +77209,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);
@@ -77781,8 +77762,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 */) {
@@ -84408,9 +84389,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));

package/package.json

@@ -2,7 +2,7 @@
     "name": "typescript",
     "author": "Microsoft Corp.",
     "homepage": "https://www.typescriptlang.org/",
-    "version": "4.8.0-dev.20220714",
+    "version": "4.8.0-dev.20220717",
     "license": "Apache-2.0",
     "description": "TypeScript is a language for application scale JavaScript development",
     "keywords": [