Consider index signatures as optional properties in contextual type discrimination

src/compiler/checker.ts

@@ -22701,7 +22701,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
             let matched = false;
             for (let i = 0; i < types.length; i++) {
                 if (include[i]) {
-                    const targetType = getTypeOfPropertyOfType(types[i], propertyName);
+                    const targetType = getTypeOfPropertyOrOptionalIndexSignature(types[i], propertyName);
                     if (targetType && related(getDiscriminatingType(), targetType)) {
                         matched = true;
                     }
@@ -22719,6 +22719,15 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
         }
         const filtered = contains(include, Ternary.False) ? getUnionType(types.filter((_, i) => include[i])) : target;
         return filtered.flags & TypeFlags.Never ? target : filtered;
+
+        function getTypeOfPropertyOrOptionalIndexSignature(type: Type, name: __String): Type | undefined {
+            let propType = getTypeOfPropertyOfType(type, name);
+            if (propType) {
+                return propType;
+            }
+            propType = getApplicableIndexInfoForName(type, name)?.type;
+            return propType && addOptionality(propType, /*isProperty*/ true, /*isOptional*/ true);
+        }
     }
 
     /**

tests/baselines/reference/discriminatedUnionWithIndexSignature.js

@@ -0,0 +1,42 @@
+//// [discriminatedUnionWithIndexSignature.ts]
+export interface UnionAltA {
+    type?: 'text';
+}
+
+export interface UnionAltB {
+    type?: 'image' | 'video' | 'document';
+}
+
+export type ValueUnion = UnionAltA | UnionAltB;
+
+export type MapOrSingleton =
+    | {
+        [key: string]: ValueUnion;
+    }
+    | ValueUnion;
+
+const withoutAsConst: MapOrSingleton = {
+    1: {
+        type: 'text' /*as const*/,
+    },
+};
+
+const withAsConst: MapOrSingleton = {
+    1: {
+        type: 'text' as const,
+    },
+};
+
+//// [discriminatedUnionWithIndexSignature.js]
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var withoutAsConst = {
+    1: {
+        type: 'text' /*as const*/,
+    },
+};
+var withAsConst = {
+    1: {
+        type: 'text',
+    },
+};

tests/baselines/reference/discriminatedUnionWithIndexSignature.symbols

@@ -0,0 +1,57 @@
+=== tests/cases/compiler/discriminatedUnionWithIndexSignature.ts ===
+export interface UnionAltA {
+>UnionAltA : Symbol(UnionAltA, Decl(discriminatedUnionWithIndexSignature.ts, 0, 0))
+
+    type?: 'text';
+>type : Symbol(UnionAltA.type, Decl(discriminatedUnionWithIndexSignature.ts, 0, 28))
+}
+
+export interface UnionAltB {
+>UnionAltB : Symbol(UnionAltB, Decl(discriminatedUnionWithIndexSignature.ts, 2, 1))
+
+    type?: 'image' | 'video' | 'document';
+>type : Symbol(UnionAltB.type, Decl(discriminatedUnionWithIndexSignature.ts, 4, 28))
+}
+
+export type ValueUnion = UnionAltA | UnionAltB;
+>ValueUnion : Symbol(ValueUnion, Decl(discriminatedUnionWithIndexSignature.ts, 6, 1))
+>UnionAltA : Symbol(UnionAltA, Decl(discriminatedUnionWithIndexSignature.ts, 0, 0))
+>UnionAltB : Symbol(UnionAltB, Decl(discriminatedUnionWithIndexSignature.ts, 2, 1))
+
+export type MapOrSingleton =
+>MapOrSingleton : Symbol(MapOrSingleton, Decl(discriminatedUnionWithIndexSignature.ts, 8, 47))
+
+    | {
+        [key: string]: ValueUnion;
+>key : Symbol(key, Decl(discriminatedUnionWithIndexSignature.ts, 12, 9))
+>ValueUnion : Symbol(ValueUnion, Decl(discriminatedUnionWithIndexSignature.ts, 6, 1))
+    }
+    | ValueUnion;
+>ValueUnion : Symbol(ValueUnion, Decl(discriminatedUnionWithIndexSignature.ts, 6, 1))
+
+const withoutAsConst: MapOrSingleton = {
+>withoutAsConst : Symbol(withoutAsConst, Decl(discriminatedUnionWithIndexSignature.ts, 16, 5))
+>MapOrSingleton : Symbol(MapOrSingleton, Decl(discriminatedUnionWithIndexSignature.ts, 8, 47))
+
+    1: {
+>1 : Symbol(1, Decl(discriminatedUnionWithIndexSignature.ts, 16, 40))
+
+        type: 'text' /*as const*/,
+>type : Symbol(type, Decl(discriminatedUnionWithIndexSignature.ts, 17, 8))
+
+    },
+};
+
+const withAsConst: MapOrSingleton = {
+>withAsConst : Symbol(withAsConst, Decl(discriminatedUnionWithIndexSignature.ts, 22, 5))
+>MapOrSingleton : Symbol(MapOrSingleton, Decl(discriminatedUnionWithIndexSignature.ts, 8, 47))
+
+    1: {
+>1 : Symbol(1, Decl(discriminatedUnionWithIndexSignature.ts, 22, 37))
+
+        type: 'text' as const,
+>type : Symbol(type, Decl(discriminatedUnionWithIndexSignature.ts, 23, 8))
+>const : Symbol(const)
+
+    },
+};

tests/baselines/reference/discriminatedUnionWithIndexSignature.types

@@ -0,0 +1,53 @@
+=== tests/cases/compiler/discriminatedUnionWithIndexSignature.ts ===
+export interface UnionAltA {
+    type?: 'text';
+>type : "text" | undefined
+}
+
+export interface UnionAltB {
+    type?: 'image' | 'video' | 'document';
+>type : "image" | "video" | "document" | undefined
+}
+
+export type ValueUnion = UnionAltA | UnionAltB;
+>ValueUnion : UnionAltA | UnionAltB
+
+export type MapOrSingleton =
+>MapOrSingleton : ValueUnion | { [key: string]: ValueUnion; }
+
+    | {
+        [key: string]: ValueUnion;
+>key : string
+    }
+    | ValueUnion;
+
+const withoutAsConst: MapOrSingleton = {
+>withoutAsConst : MapOrSingleton
+>{    1: {        type: 'text' /*as const*/,    },} : { 1: { type: "text"; }; }
+
+    1: {
+>1 : { type: "text"; }
+>{        type: 'text' /*as const*/,    } : { type: "text"; }
+
+        type: 'text' /*as const*/,
+>type : "text"
+>'text' : "text"
+
+    },
+};
+
+const withAsConst: MapOrSingleton = {
+>withAsConst : MapOrSingleton
+>{    1: {        type: 'text' as const,    },} : { 1: { type: "text"; }; }
+
+    1: {
+>1 : { type: "text"; }
+>{        type: 'text' as const,    } : { type: "text"; }
+
+        type: 'text' as const,
+>type : "text"
+>'text' as const : "text"
+>'text' : "text"
+
+    },
+};

tests/cases/compiler/discriminatedUnionWithIndexSignature.ts

@@ -0,0 +1,29 @@
+// @strict: true
+
+export interface UnionAltA {
+    type?: 'text';
+}
+
+export interface UnionAltB {
+    type?: 'image' | 'video' | 'document';
+}
+
+export type ValueUnion = UnionAltA | UnionAltB;
+
+export type MapOrSingleton =
+    | {
+        [key: string]: ValueUnion;
+    }
+    | ValueUnion;
+
+const withoutAsConst: MapOrSingleton = {
+    1: {
+        type: 'text' /*as const*/,
+    },
+};
+
+const withAsConst: MapOrSingleton = {
+    1: {
+        type: 'text' as const,
+    },
+};