in operator typeguard can widen types

src/compiler/checker.ts

@@ -741,7 +741,7 @@ namespace ts {
 
         const tupleTypes = new Map<string, GenericType>();
         const unionTypes = new Map<string, UnionType>();
-        const intersectionTypes = new Map<string, Type>();
+        const intersectionTypes = new Map<string, IntersectionType>();
         const stringLiteralTypes = new Map<string, StringLiteralType>();
         const numberLiteralTypes = new Map<number, NumberLiteralType>();
         const bigIntLiteralTypes = new Map<string, BigIntLiteralType>();
@@ -12118,8 +12118,11 @@ namespace ts {
             return property;
         }
 
-        function getPropertyOfUnionOrIntersectionType(type: UnionOrIntersectionType, name: __String, skipObjectFunctionPropertyAugment?: boolean): Symbol | undefined {
+        function getPropertyOfUnionOrIntersectionType(type: UnionOrIntersectionType, name: __String, skipObjectFunctionPropertyAugment?: boolean, includePartialProperties?: boolean): Symbol | undefined {
             const property = getUnionOrIntersectionProperty(type, name, skipObjectFunctionPropertyAugment);
+            if (includePartialProperties) {
+                return property;
+            }
             // We need to filter out partial properties in union types
             return property && !(getCheckFlags(property) & CheckFlags.ReadPartial) ? property : undefined;
         }
@@ -12197,7 +12200,7 @@ namespace ts {
          * @param type a type to look up property from
          * @param name a name of property to look up in a given type
          */
-        function getPropertyOfType(type: Type, name: __String, skipObjectFunctionPropertyAugment?: boolean): Symbol | undefined {
+        function getPropertyOfType(type: Type, name: __String, skipObjectFunctionPropertyAugment?: boolean, includePartialProperties?: boolean): Symbol | undefined {
             type = getReducedApparentType(type);
             if (type.flags & TypeFlags.Object) {
                 const resolved = resolveStructuredTypeMembers(type as ObjectType);
@@ -12219,7 +12222,7 @@ namespace ts {
                 return getPropertyOfObjectType(globalObjectType, name);
             }
             if (type.flags & TypeFlags.UnionOrIntersection) {
-                return getPropertyOfUnionOrIntersectionType(type as UnionOrIntersectionType, name, skipObjectFunctionPropertyAugment);
+                return getPropertyOfUnionOrIntersectionType(type as UnionOrIntersectionType, name, skipObjectFunctionPropertyAugment, includePartialProperties);
             }
             return undefined;
         }
@@ -14346,6 +14349,31 @@ 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);
+            let type = intersectionTypes.get(id);
+            if (!type) {
+                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) {
@@ -14585,7 +14613,7 @@ namespace ts {
                 return typeSet[0];
             }
             const id = getTypeListId(typeSet) + getAliasId(aliasSymbol, aliasTypeArguments);
-            let result = intersectionTypes.get(id);
+            let result: Type | undefined = intersectionTypes.get(id);
             if (!result) {
                 if (includes & TypeFlags.Union) {
                     if (intersectUnionsOfPrimitiveTypes(typeSet)) {
@@ -14620,7 +14648,7 @@ namespace ts {
                 else {
                     result = createIntersectionType(typeSet, aliasSymbol, aliasTypeArguments);
                 }
-                intersectionTypes.set(id, result);
+                intersectionTypes.set(id, result as IntersectionType);
             }
             return result;
         }
@@ -23074,14 +23102,14 @@ namespace ts {
             return type.flags & TypeFlags.UnionOrIntersection ? every((type as UnionOrIntersectionType).types, f) : f(type);
         }
 
-        function filterType(type: Type, f: (t: Type) => boolean): 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;
+        function filterUnionOrIntersectionType(type: UnionOrIntersectionType, f: (t: Type) => boolean): Type {
+            const types = type.types;
+            const filtered = filter(types, f);
+            if (filtered === types) {
+                return type;
+            }
+            if (isUnionType(type)) {
+                const origin = type.origin;
                 let newOrigin: Type | undefined;
                 if (origin && origin.flags & TypeFlags.Union) {
                     // If the origin type is a (denormalized) union type, filter its non-union constituents. If that ends
@@ -23098,7 +23126,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 (isUnionType(type)) {
+                return filterUnionOrIntersectionType(type, f);
             }
             return type.flags & TypeFlags.Never || f(type) ? type : neverType;
         }
@@ -24062,12 +24097,61 @@ 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 (isObjectType(type) && type.objectFlags & ObjectFlags.Anonymous) {
+                    return widenObjectType(type, newSymbol);
+                }
+                // If type is intersection, add the symbol to the first anonymous object component of the intersection
+                if (isIntersectionType(type)) {
+                    const objectSubtype = type.types.find(t => isObjectType(t) && t.objectFlags & ObjectFlags.Anonymous) as ObjectType | undefined;
+                    if (objectSubtype) {
+                        const restOfIntersection = filterUnionOrIntersectionType(type, 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
+                    || isUnionOrIntersectionType(type) && filterUnionOrIntersectionType(type, t => t.symbol === globalThisSymbol) !== neverType
+                   ) {
+                    return type;
+                }
+                const someDirectSubtypeContainsProp = getPropertyOfType(type, name, /* skipObjectFunctionPropertyAugment */ false, /* includePartialProperties */ true);
+                if (someDirectSubtypeContainsProp) {
+                    // If union, filter out all components not containing the property
+                    // Otherwise, either return the type or never
+                    if (type.flags & (TypeFlags.Object | TypeFlags.UnionOrIntersection)
+                        || isThisTypeParameter(type)
+                    ) {
+                        return filterType(type, t => isTypePresencePossible(t, name, assumeTrue));
+                        return isTypePresencePossible(type, name, assumeTrue) ? type : neverType;
+                    }
+                }
+                // only widen property when the type does not contain string-index/name in any of the constituents.
+                if (assumeTrue && !someDirectSubtypeContainsProp && !getIndexInfoOfType(type, stringType)) {
+                    const addSymbol = createSymbol(SymbolFlags.Property, name);
+                    addSymbol.type = unknownType;
+                    return widenTypeWithSymbol(type, addSymbol);
                 }
                 return type;
             }
@@ -24136,7 +24220,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;

src/compiler/tsconfig.json

@@ -44,6 +44,7 @@
         "checker.ts",
         "visitorPublic.ts",
         "sourcemap.ts",
+        "typeTests.ts",
         "transformers/utilities.ts",
         "transformers/destructuring.ts",
         "transformers/taggedTemplate.ts",

src/compiler/typeTests.ts

@@ -0,0 +1,18 @@
+/* @internal */
+namespace ts {
+    export function isUnionOrIntersectionType(type: Type): type is UnionOrIntersectionType {
+        return !!(type.flags & TypeFlags.UnionOrIntersection);
+    }
+
+    export function isUnionType(type: Type): type is UnionType {
+        return !!(type.flags & TypeFlags.Union);
+    }
+
+    export function isIntersectionType(type: Type): type is IntersectionType {
+        return !!(type.flags & TypeFlags.Intersection);
+    }
+
+    export function isObjectType(type: Type): type is ObjectType {
+        return !!(type.flags & TypeFlags.Object);
+    }
+}

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, U>(target: T, source: U): T & U; <T, U, V>(target: T, source1: U, source2: V): T & U & V; <T, U, V, W>(target: T, source1: U, source2: V, source3: W): T & U & V & W; (target: object, ...sources: any[]): any; }
 >Object : ObjectConstructor
 >assign : { <T, U>(target: T, source: U): T & U; <T, U, V>(target: T, source1: U, source2: V): T & U & V; <T, 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; }