Consistently propagate 'any' and 'never' types in type inference

ahejlsberg · ahejlsberg · commit e5b568f9f415 · 2018-02-28T14:08:25.000-08:00
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
@@ -11490,20 +11490,21 @@ namespace ts {
             let symbolStack: Symbol[];
             let visited: Map<boolean>;
             let contravariant = false;
+            let propagationType: Type;
             inferFromTypes(originalSource, originalTarget);
 
             function inferFromTypes(source: Type, target: Type) {
                 if (!couldContainTypeVariables(target)) {
                     return;
                 }
-                if (source === neverType || source === wildcardType) {
-                    // We are inferring from 'never' or the wildcard type. We want to infer this
-                    // type for every type parameter referenced in the target type, so we infer from
-                    // target to itself with a flag we check when recording candidates.
-                    const savePriority = priority;
-                    priority |= source === neverType ? InferencePriority.Never : InferencePriority.Wildcard;
+                if (source.flags & (TypeFlags.Any | TypeFlags.Never) && source !== silentNeverType) {
+                    // We are inferring from 'any' or 'never'. We want to infer this type for every type parameter
+                    // referenced in the target type, so we record the propagation type and infer from the target
+                    // to itself. Then, as we find candidates we substitute the propagation type.
+                    const savePropagationType = propagationType;
+                    propagationType = source;
                     inferFromTypes(target, target);
-                    priority = savePriority;
+                    propagationType = savePropagationType;
                     return;
                 }
                 if (source.aliasSymbol && source.aliasTypeArguments && source.aliasSymbol === target.aliasSymbol) {
@@ -11567,16 +11568,13 @@ namespace ts {
                     const inference = getInferenceInfoForType(target);
                     if (inference) {
                         if (!inference.isFixed) {
-                            const p = priority & InferencePriority.Mask;
-                            if (inference.priority === undefined || p < inference.priority) {
+                            if (inference.priority === undefined || priority < inference.priority) {
                                 inference.candidates = undefined;
                                 inference.contraCandidates = undefined;
-                                inference.priority = p;
+                                inference.priority = priority;
                             }
-                            if (p === inference.priority) {
-                                const candidate = priority & InferencePriority.Never ? neverType :
-                                    priority & InferencePriority.Wildcard ? wildcardType :
-                                    source;
+                            if (priority === inference.priority) {
+                                const candidate = propagationType || source;
                                 if (contravariant) {
                                     inference.contraCandidates = append(inference.contraCandidates, candidate);
                                 }
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
@@ -3915,9 +3915,6 @@ namespace ts {
         ReturnType        = 1 << 2,  // Inference made from return type of generic function
         NoConstraints     = 1 << 3,  // Don't infer from constraints of instantiable types
         AlwaysStrict      = 1 << 4,  // Always use strict rules for contravariant inferences
-        Wildcard          = 1 << 5,  // Inferring from wildcard type
-        Never             = 1 << 6,  // Inferring from never type
-        Mask = NakedTypeVariable | MappedType | ReturnType,
     }
 
     /* @internal */

Original file line number	Diff line number	Diff line change
`@@ -3915,9 +3915,6 @@ namespace ts {`
`3915`	`3915`	`ReturnType = 1 << 2, // Inference made from return type of generic function`
`3916`	`3916`	`NoConstraints = 1 << 3, // Don't infer from constraints of instantiable types`
`3917`	`3917`	`AlwaysStrict = 1 << 4, // Always use strict rules for contravariant inferences`
`3918`		`- Wildcard = 1 << 5, // Inferring from wildcard type`
`3919`		`- Never = 1 << 6, // Inferring from never type`
`3920`		`- Mask = NakedTypeVariable \| MappedType \| ReturnType,`
`3921`	`3918`	`}`
`3922`	`3919`
`3923`	`3920`	`/* @internal */`