in operator typeguard can widen types

src/compiler/checker.ts

@@ -14773,6 +14773,32 @@ namespace ts {
             return type;
         }
 
+        // This function assumes the constituent type list is sorted and deduplicated.
+        function getIntersectionTypeFromSortedList(types: Type[], objectFlags: ObjectFlags, aliasSymbol?: Symbol, aliasTypeArguments?: readonly Type[]): Type {
+            if (types.length === 0) {
+                return neverType;
+            }
+            if (types.length === 1) {
+                return types[0];
+            }
+            const id = getTypeListId(types) + getAliasId(aliasSymbol, aliasTypeArguments);
+            const existingType = intersectionTypes.get(id);
+            if (existingType) {
+                return existingType;
+            }
+            const type = createType(TypeFlags.Intersection) as IntersectionType;
+            type.objectFlags = objectFlags | getPropagatingFlagsOfTypes(types, /*excludeKinds*/ TypeFlags.Nullable);
+            type.types = types;
+            type.aliasSymbol = aliasSymbol;
+            type.aliasTypeArguments = aliasTypeArguments;
+            if (types.length === 2 && types[0].flags & TypeFlags.BooleanLiteral && types[1].flags & TypeFlags.BooleanLiteral) {
+                type.flags |= TypeFlags.Boolean;
+                (type as IntersectionType & IntrinsicType).intrinsicName = "boolean";
+            }
+            intersectionTypes.set(id, type);
+            return type;
+        }
+
         function getTypeFromUnionTypeNode(node: UnionTypeNode): Type {
             const links = getNodeLinks(node);
             if (!links.resolvedType) {
@@ -23724,13 +23750,13 @@ namespace ts {
             return type.flags & TypeFlags.UnionOrIntersection ? every((type as UnionOrIntersectionType).types, f) : f(type);
         }
 
-        function filterType(type: Type, f: (t: Type) => boolean): Type {
+        function filterUnionOrIntersectionType(type: UnionOrIntersectionType, f: (t: Type) => boolean): Type {
+            const types = type.types;
+            const filtered = filter(types, f);
+            if (filtered === types) {
+                return type;
+            }
             if (type.flags & TypeFlags.Union) {
-                const types = (type as UnionType).types;
-                const filtered = filter(types, f);
-                if (filtered === types) {
-                    return type;
-                }
                 const origin = (type as UnionType).origin;
                 let newOrigin: Type | undefined;
                 if (origin && origin.flags & TypeFlags.Union) {
@@ -23748,7 +23774,14 @@ namespace ts {
                         newOrigin = createOriginUnionOrIntersectionType(TypeFlags.Union, originFiltered);
                     }
                 }
-                return getUnionTypeFromSortedList(filtered, (type as UnionType).objectFlags, /*aliasSymbol*/ undefined, /*aliasTypeArguments*/ undefined, newOrigin);
+                return getUnionTypeFromSortedList(filtered, type.objectFlags, /*aliasSymbol*/ undefined, /*aliasTypeArguments*/ undefined, newOrigin);
+            }
+            return getIntersectionTypeFromSortedList(filtered, type.objectFlags);
+        }
+
+        function filterType(type: Type, f: (t: Type) => boolean): Type {
+            if (type.flags & TypeFlags.Union) {
+                return filterUnionOrIntersectionType(type as UnionType, f);
             }
             return type.flags & TypeFlags.Never || f(type) ? type : neverType;
         }
@@ -24754,12 +24787,58 @@ namespace ts {
                 return getApplicableIndexInfoForName(type, propName) ? true : !assumeTrue;
             }
 
-            function narrowByInKeyword(type: Type, name: __String, assumeTrue: boolean) {
-                if (type.flags & TypeFlags.Union
-                    || type.flags & TypeFlags.Object && declaredType !== type
-                    || isThisTypeParameter(type)
-                    || type.flags & TypeFlags.Intersection && every((type as IntersectionType).types, t => t.symbol !== globalThisSymbol)) {
-                    return filterType(type, t => isTypePresencePossible(t, name, assumeTrue));
+            function widenTypeWithSymbol(type: Type, newSymbol: Symbol): Type {
+                // If type is this/any/unknown, it cannot be widened.
+                if ((type.flags & TypeFlags.AnyOrUnknown) || isThisTypeParameter(type)) {
+                    return type;
+                }
+                // If type is anonymous object, add the symbol directly
+                if (getObjectFlags(type) & ObjectFlags.Anonymous) {
+                    return widenObjectType(type as ObjectType, newSymbol);
+                }
+                // If type is intersection, add the symbol to the first anonymous object component of the intersection
+                if (type.flags & TypeFlags.Intersection) {
+                    const objectSubtype = (type as IntersectionType).types.find(t => getObjectFlags(t) & ObjectFlags.Anonymous) as ObjectType | undefined;
+                    if (objectSubtype) {
+                        const restOfIntersection = filterUnionOrIntersectionType(type as IntersectionType, t => t !== objectSubtype);
+                        return createIntersectionType([restOfIntersection, widenObjectType(objectSubtype, newSymbol)]);
+                    }
+                }
+
+                // Otherwise, just add the new object type as an intersection
+                const newTypeWithSymbol = widenObjectType(createAnonymousType(undefined, createSymbolTable(), emptyArray, emptyArray, emptyArray), newSymbol);
+                return createIntersectionType([type, newTypeWithSymbol]);
+
+                function widenObjectType(type: ObjectType, newSymbol: Symbol): Type {
+                    const members = createSymbolTable();
+                    if (type.members !== undefined) {
+                        mergeSymbolTable(members, type.members);
+                    }
+                    members.set(newSymbol.escapedName, newSymbol);
+                    return createAnonymousType(undefined, members, type.callSignatures ?? emptyArray, type.constructSignatures ?? emptyArray, type.indexInfos ?? emptyArray);
+                }
+            }
+
+            function narrowOrWidenTypeByInKeyword(type: Type, name: __String, assumeTrue: boolean) {
+                // If type contains global this, don't touch it
+                if (type.symbol === globalThisSymbol
+                    || (type.flags & TypeFlags.UnionOrIntersection
+                        && filterUnionOrIntersectionType(type as UnionOrIntersectionType, t => t.symbol === globalThisSymbol) !== neverType)
+                   ) {
+                    return type;
+                }
+
+                // If union, filter out all components not containing the property
+                const subtypeWithProp = filterType(type, t => isTypePresencePossible(t, name, assumeTrue));
+                if (subtypeWithProp !== neverType || getPropertyOfType(type, name, /* skipObjectFunctionPropertyAugment */ false)) {
+                    return subtypeWithProp;
+                }
+
+                // only widen property when the type does not contain string-index/name in any of the constituents.
+                if (assumeTrue && !getIndexInfoOfType(type, stringType)) {
+                    const addSymbol = createSymbol(SymbolFlags.Property, name);
+                    addSymbol.type = unknownType;
+                    return widenTypeWithSymbol(type, addSymbol);
                 }
                 return type;
             }
@@ -24828,7 +24907,7 @@ namespace ts {
                                 return getTypeWithFacts(type, assumeTrue ? TypeFacts.NEUndefined : TypeFacts.EQUndefined);
                             }
                             if (isMatchingReference(reference, target)) {
-                                return narrowByInKeyword(type, name, assumeTrue);
+                                return narrowOrWidenTypeByInKeyword(type, name, assumeTrue);
                             }
                         }
                         break;

tests/baselines/reference/conditionalTypeDoesntSpinForever.types

@@ -212,12 +212,12 @@ export enum PubSubRecordIsStoredInRedisAsA {
 >buildPubSubRecordType(Object.assign({}, soFar, {identifier: instance as TYPE}) as SO_FAR & {identifier: TYPE}) : BuildPubSubRecordType<SO_FAR & { identifier: TYPE; }>
 >buildPubSubRecordType : <SO_FAR>(soFar: SO_FAR) => BuildPubSubRecordType<SO_FAR>
 >Object.assign({}, soFar, {identifier: instance as TYPE}) as SO_FAR & {identifier: TYPE} : SO_FAR & { identifier: TYPE; }
->Object.assign({}, soFar, {identifier: instance as TYPE}) : SO_FAR & { identifier: TYPE; }
+>Object.assign({}, soFar, {identifier: instance as TYPE}) : SO_FAR & { record: unknown; } & { identifier: TYPE; }
 >Object.assign : { <T extends {}, U>(target: T, source: U): T & U; <T extends {}, U, V>(target: T, source1: U, source2: V): T & U & V; <T extends {}, U, V, W>(target: T, source1: U, source2: V, source3: W): T & U & V & W; (target: object, ...sources: any[]): any; }
 >Object : ObjectConstructor
 >assign : { <T extends {}, U>(target: T, source: U): T & U; <T extends {}, U, V>(target: T, source1: U, source2: V): T & U & V; <T extends {}, U, V, W>(target: T, source1: U, source2: V, source3: W): T & U & V & W; (target: object, ...sources: any[]): any; }
 >{} : {}
->soFar : SO_FAR
+>soFar : SO_FAR & { record: unknown; }
 >{identifier: instance as TYPE} : { identifier: TYPE; }
 >identifier : TYPE
 >instance as TYPE : TYPE
@@ -389,13 +389,13 @@ export enum PubSubRecordIsStoredInRedisAsA {
 >soFar : SO_FAR
 >"object" in soFar : boolean
 >"object" : "object"
->soFar : SO_FAR
+>soFar : SO_FAR & { identifier: unknown; }
 >"maxMsToWaitBeforePublishing" in soFar : boolean
 >"maxMsToWaitBeforePublishing" : "maxMsToWaitBeforePublishing"
->soFar : SO_FAR
+>soFar : SO_FAR & { identifier: unknown; object: unknown; }
 >"PubSubRecordIsStoredInRedisAsA" in soFar : boolean
 >"PubSubRecordIsStoredInRedisAsA" : "PubSubRecordIsStoredInRedisAsA"
->soFar : SO_FAR
+>soFar : SO_FAR & { identifier: unknown; object: unknown; maxMsToWaitBeforePublishing: unknown; }
 >{} : {}
 >{      type: soFar,      fields: () => new Set(Object.keys(soFar) as (keyof SO_FAR)[]),      hasField: (fieldName: string | number | symbol) => fieldName in soFar    } : { type: SO_FAR; fields: () => Set<keyof SO_FAR>; hasField: (fieldName: string | number | symbol) => boolean; }