Strengthen and unify negated type <-> filtering conditional workaround rule

Author: weswigham

tsc/internal/checker/checker.go

@@ -152,6 +152,11 @@ type CachedTypeKey struct {
 	typeId TypeId
 }
 
+type DistributiveInstantiationKey struct {
+	typeId          TypeId
+	typeParameterId TypeId
+}
+
 // NarrowedTypeKey
 
 type NarrowedTypeKey struct {
@@ -651,6 +656,7 @@ type Checker struct {
 	thisExpandoLocations                        map[*ast.Symbol]*ast.Node
 	subtypeReductionCache                       map[CacheHashKey][]*Type
 	cachedTypes                                 map[CachedTypeKey]*Type
+	distributiveInstantiationCache              map[DistributiveInstantiationKey]bool
 	cachedSignatures                            map[CachedSignatureKey]*Signature
 	undefinedProperties                         map[*ast.Symbol]*ast.Symbol
 	narrowedTypes                               map[NarrowedTypeKey]*Type
@@ -990,6 +996,7 @@ func NewChecker(program Program, tracer *Tracer) (*Checker, *sync.Mutex) {
 	c.thisExpandoLocations = make(map[*ast.Symbol]*ast.Node)
 	c.subtypeReductionCache = make(map[CacheHashKey][]*Type)
 	c.cachedTypes = make(map[CachedTypeKey]*Type)
+	c.distributiveInstantiationCache = make(map[DistributiveInstantiationKey]bool)
 	c.cachedSignatures = make(map[CachedSignatureKey]*Signature)
 	c.undefinedProperties = make(map[*ast.Symbol]*ast.Symbol)
 	c.narrowedTypes = make(map[NarrowedTypeKey]*Type)

tsc/internal/checker/relater.go

@@ -3616,8 +3616,8 @@ func (r *Relater) structuredTypeRelatedToWorker(source *Type, target *Type, repo
 				nameType := r.c.getNameTypeFromMappedType(targetType)
 				constraintType := r.c.getConstraintTypeFromMappedType(targetType)
 				var targetKeys *Type
-				isFiltering := nameType != nil && r.c.isMappedTypeWithKeyofConstraintDeclaration(targetType)
-				if isFiltering {
+				isRemappedKeyof := nameType != nil && r.c.isMappedTypeWithKeyofConstraintDeclaration(targetType)
+				if isRemappedKeyof {
 					// we need to get the apparent mappings and union them with the generic mappings, since some properties may be
 					// missing from the `constraintType` which will otherwise be mapped in the object
 					mappedKeys := r.c.getApparentMappedTypeKeys(nameType, targetType)
@@ -3628,15 +3628,14 @@ func (r *Relater) structuredTypeRelatedToWorker(source *Type, target *Type, repo
 				} else {
 					targetKeys = constraintType
 				}
-				if isFiltering && source.flags&TypeFlagsIntersection != 0 && r.someTypeRelatedToType(source, constraintType, false, intersectionState) == TernaryTrue {
-					// run the filter over `source` - some part of `source` is related to the constraint - if source's other elements end up filtering the same way the nameType does, the assignment can pass
-					// This effectively is a workaround for a lack of distributive conditional/distributive homomorphic mapped types relationship rules that uses execution of the distribution (even at higher order)
-					// to approximate a better result.
-					// See the homomorphic case in tsc\testdata\tests\cases\compiler\indexMappedTypeWithFilteredKeysWithNegation.ts
-					sourceInstantiatedTarget := r.c.instantiateType(nameType, newSimpleTypeMapper(r.c.getTypeParameterFromMappedType(targetType), source))
-					broadTargetKeys := r.c.getUnionType([]*Type{targetKeys, sourceInstantiatedTarget})
-					if r.isRelatedTo(source, broadTargetKeys, RecursionFlagsTarget, false) == TernaryTrue {
-						return TernaryTrue
+				if isRemappedKeyof && source.flags&TypeFlagsIntersection != 0 {
+					if filteredNameType := r.getOptionalSimplificationOfConditional(nameType); filteredNameType != nil && r.someTypeRelatedToType(source, constraintType, false, intersectionState) == TernaryTrue {
+						// Apply the filter only to a source already constrained to the mapped keys.
+						sourceInstantiatedTarget := r.c.instantiateType(filteredNameType, newSimpleTypeMapper(r.c.getTypeParameterFromMappedType(targetType), source))
+						broadTargetKeys := r.c.getUnionType([]*Type{targetKeys, sourceInstantiatedTarget})
+						if r.isRelatedTo(source, broadTargetKeys, RecursionFlagsTarget, false) == TernaryTrue {
+							return TernaryTrue
+						}
 					}
 				}
 				if r.isRelatedTo(source, targetKeys, RecursionFlagsTarget, reportErrors) == TernaryTrue {
@@ -4024,32 +4023,72 @@ func (r *Relater) structuredTypeRelatedToWorker(source *Type, target *Type, repo
 	return TernaryFalse
 }
 
+// TODO: Replace this heuristic with proper distributive conditional type relationship rules.
+// For a distributive A extends B ? never : Q<A> without infer parameters, rewrite to Q<A & not B>.
+// A definitely false check uses Q<A> unchanged; a definitely true check cannot use the rewrite.
+// Otherwise B must be independent of A, and Q<never> must be never. The conditional already distributes,
+// but we also probe whether Q<X | Y> agrees with Q<X> | Q<Y> before moving the union inside Q.
+// See Repeated in indexMappedTypeWithFilteredKeysWithNegationErrors.ts, where moving the union
+// inside `${A}-${A}` would lose the correlation between occurrences of A.
 func (r *Relater) getOptionalSimplificationOfConditional(target *Type) *Type {
 	if target.flags&TypeFlagsConditional == 0 {
 		return nil
 	}
-	// TODO: This is a kludge for not having proper rules for relating distributive conditional types.
-	// We rewrite `A extends B ? never : Q<A>` into `Q<A & not B>` - provided that substitution
-	// actually changes it. This is not *particularly* accurate, but enables the common case of relating a filtering mapped type to the equivalent filtering negated type.
-	// See the non-homomorphic case in tsc\testdata\tests\cases\compiler\indexMappedTypeWithFilteredKeysWithNegation.ts for an example.
-	root := target.AsConditionalType().root
-	if root.isDistributive && r.c.getTrueTypeFromConditionalType(target).flags&TypeFlagsNever != 0 {
-		f := r.c.getFalseTypeFromConditionalType(target)
-		remappedFalseType := r.c.instantiateType(
-			r.c.getTypeFromTypeNode(root.node.FalseType),
-			r.c.combineTypeMappers(
-				newSimpleTypeMapper(
-					getNonDistributedTypeParameter(root.checkType),
-					r.c.getIntersectionType([]*Type{root.checkType, r.c.getNegatedType(root.extendsType)}),
-				),
-				target.AsConditionalType().mapper,
-			),
-		)
-		if remappedFalseType != f {
-			return remappedFalseType
-		}
+	conditional := target.AsConditionalType()
+	root := conditional.root
+	if !root.isDistributive || len(root.inferTypeParameters) != 0 || r.c.getTrueTypeFromConditionalType(target).flags&TypeFlagsNever == 0 {
+		return nil
 	}
-	return nil
+	permissiveExtendsType := r.c.getPermissiveInstantiation(conditional.extendsType)
+	skipTrue := !someType(r.c.getPermissiveInstantiation(conditional.checkType), func(t *Type) bool {
+		return r.c.isTypeAssignableTo(t, permissiveExtendsType)
+	})
+	if skipTrue {
+		return r.c.getFalseTypeFromConditionalType(target)
+	}
+	if r.c.isTypeAssignableTo(r.c.getRestrictiveInstantiation(conditional.checkType), r.c.getRestrictiveInstantiation(conditional.extendsType)) {
+		return nil
+	}
+	checkType := getNonDistributedTypeParameter(root.checkType)
+	if r.c.isTypeParameterPossiblyReferenced(checkType, root.node.ExtendsType) {
+		return nil
+	}
+	falseType := r.c.getTypeFromTypeNode(root.node.FalseType)
+	if !r.canDistributeTypeInstantiation(falseType, checkType) {
+		return nil
+	}
+	return r.c.instantiateType(
+		falseType,
+		r.c.combineTypeMappers(
+			newSimpleTypeMapper(checkType, r.c.getIntersectionType([]*Type{root.checkType, r.c.getNegatedType(root.extendsType)})),
+			conditional.mapper,
+		),
+	)
+}
+
+func (r *Relater) canDistributeTypeInstantiation(t *Type, typeParameter *Type) bool {
+	key := DistributiveInstantiationKey{typeId: t.id, typeParameterId: typeParameter.id}
+	if result, ok := r.c.distributiveInstantiationCache[key]; ok {
+		return result
+	}
+	// A recursive probe is unproven until the outer comparison completes.
+	r.c.distributiveInstantiationCache[key] = false
+	// Filtering can remove the entire check type, so the false branch must also preserve never.
+	if r.c.instantiateType(t, newSimpleTypeMapper(typeParameter, r.c.neverType)).flags&TypeFlagsNever == 0 {
+		return false
+	}
+	left := r.c.markerSuperType
+	right := r.c.markerOtherType
+	instantiate := func(argument *Type) *Type {
+		return r.c.getSimplifiedType(r.c.instantiateType(t, newSimpleTypeMapper(typeParameter, argument)), false /*writing*/)
+	}
+	// Require execution over unrelated union members to agree with distributing first.
+	// Use the existing identity comparison rather than introducing conditional relationship rules.
+	instantiatedUnion := instantiate(r.c.getUnionType([]*Type{left, right}))
+	unionOfInstantiations := r.c.getUnionType([]*Type{instantiate(left), instantiate(right)})
+	result := r.c.isTypeIdenticalTo(instantiatedUnion, unionOfInstantiations)
+	r.c.distributiveInstantiationCache[key] = result
+	return result
 }
 
 func (r *Relater) typeArgumentsRelatedTo(sources []*Type, targets []*Type, variances []VarianceFlags, reportErrors bool, intersectionState IntersectionState) Ternary {

tsc/testdata/baselines/reference/compiler/indexMappedTypeWithFilteredKeysWithNegation.js

@@ -39,6 +39,102 @@ const t1: T1 = ['b', 'c'];
 
 type S1<T> = { [K in keyof T & string as K extends '_key' ? never : K]: 1 }[LocalExclude<keyof T & string, '_key'>];
 type S2<T> = { [K in string & keyof T as K extends '_key' ? never : K]: 1 }[LocalExclude<string & keyof T, '_key'>];
+
+type ConditionalExclude<T, U> = T extends U ? never : T;
+
+function exclude<T, U>(value: T & not U): ConditionalExclude<T, U> {
+    return value;
+}
+
+type Identity<T> = T;
+type AliasedExclude<T, U> = T extends U ? never : Identity<T>;
+
+function aliasedExclude<T, U>(value: T & not U): AliasedExclude<T, U> {
+    return value;
+}
+
+function mappedExclude<T, U>(value: keyof T & not U): keyof ExcludeKey<T, U> {
+    return value;
+}
+
+type AliasedExcludeKey<T, U> = {
+    [K in keyof T as ConditionalExclude<K, U>]: T[K]
+};
+
+function aliasedMappedExclude<T, U>(value: keyof T & not U): keyof AliasedExcludeKey<T, U> {
+    return value;
+}
+
+type Prefixed<T extends string> = T extends "skip" ? never : `prefix${T}`;
+
+function prefixed<T extends string>(value: `prefix${T & not "skip"}`): Prefixed<T> {
+    return value;
+}
+
+type WithSuffix<T extends string, S extends string> = T extends "skip" ? never : `prefix${T}:${S}`;
+
+function withSuffix<T extends string, S extends string>(value: `prefix${T & not "skip"}:${S}`): WithSuffix<T, S> {
+    return value;
+}
+
+type Cased<T extends string> = Uppercase<`prefix${Lowercase<T>}`>;
+type FilteredCased<T extends string> = T extends "skip" ? never : Cased<T>;
+
+function cased<T extends string>(value: Cased<T & not "skip">): FilteredCased<T> {
+    return value;
+}
+
+type Alternatives<T extends string> = T extends "skip" ? never : `left${T}` | `right${Uppercase<T>}`;
+
+function alternatives<T extends string>(
+    value: `left${T & not "skip"}` | `right${Uppercase<T & not "skip">}`
+): Alternatives<T> {
+    return value;
+}
+
+type Branded<T> = T extends "skip" ? never : T & { brand: true };
+
+function branded<T>(value: T & not "skip" & { brand: true }): Branded<T> {
+    return value;
+}
+
+interface Values {
+    a: 1;
+    b: 2;
+    skip: 3;
+}
+
+type Lookup<T extends keyof Values> = T extends "skip" ? never : Values[T];
+
+function lookup<T extends keyof Values>(value: Values[T & not "skip"]): Lookup<T> {
+    return value;
+}
+
+type PrefixedKeys<T> = {
+    [K in keyof T & string as K extends "_key" ? never : `prefix${K}`]: T[K]
+};
+
+function prefixedKey<T>(value: `prefix${keyof T & string & not "_key"}`): keyof PrefixedKeys<T> {
+    return value;
+}
+
+type FunctionResult<T> = T extends string ? never : () => T;
+
+function falseFunction<T>(value: () => [T]): FunctionResult<[T]> {
+    return value;
+}
+
+type TupleResult<T> = T extends string ? never : [T, T];
+
+function falseTuple<T>(value: [[T], [T]]): TupleResult<[T]> {
+    return value;
+}
+
+type Nested<T extends string> = T extends "skip" ? never : ConditionalExclude<`prefix${T}`, "prefixomit">;
+
+function nested<T extends string>(value: ConditionalExclude<`prefix${T & not "skip"}`, "prefixomit">): Nested<T> {
+    return value;
+}
 
 
 //// [indexMappedTypeWithFilteredKeysWithNegation.js]
@@ -48,3 +144,45 @@ function f(test, possibleKey) {
     test[possibleKey];
 }
 const t1 = ['b', 'c'];
+function exclude(value) {
+    return value;
+}
+function aliasedExclude(value) {
+    return value;
+}
+function mappedExclude(value) {
+    return value;
+}
+function aliasedMappedExclude(value) {
+    return value;
+}
+function prefixed(value) {
+    return value;
+}
+function withSuffix(value) {
+    return value;
+}
+function cased(value) {
+    return value;
+}
+function alternatives(value) {
+    return value;
+}
+function branded(value) {
+    return value;
+}
+function lookup(value) {
+    return value;
+}
+function prefixedKey(value) {
+    return value;
+}
+function falseFunction(value) {
+    return value;
+}
+function falseTuple(value) {
+    return value;
+}
+function nested(value) {
+    return value;
+}