Let properties having primitive types discriminate object unions

src/compiler/checker.ts

@@ -27281,16 +27281,29 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
         return false;
     }
 
-    function isDiscriminantProperty(type: Type | undefined, name: __String) {
+    // The flag `considerNonUniformPrimitivePropDiscriminant`, when enabled, introduces a new criterion for a property to be considered discriminant:
+    // 1 The property must be non-uniform
+    // 2 The property must include at least one primitive type as a possible type
+    function isDiscriminantProperty(type: Type | undefined, name: __String, considerNonUniformPrimitivePropDiscriminant: boolean = true) {
         if (type && type.flags & TypeFlags.Union) {
             const prop = getUnionOrIntersectionProperty(type as UnionType, name);
             if (prop && getCheckFlags(prop) & CheckFlags.SyntheticProperty) {
+                const propType = getTypeOfSymbol(prop);
                 // NOTE: cast to TransientSymbol should be safe because only TransientSymbols can have CheckFlags.SyntheticProperty
-                if ((prop as TransientSymbol).links.isDiscriminantProperty === undefined) {
-                    (prop as TransientSymbol).links.isDiscriminantProperty = ((prop as TransientSymbol).links.checkFlags & CheckFlags.Discriminant) === CheckFlags.Discriminant &&
-                        !isGenericType(getTypeOfSymbol(prop));
+                const transientSymbol = prop as TransientSymbol;
+                transientSymbol.links.isDiscriminantProperty ??= new Map();
+
+                let isDiscriminant = transientSymbol.links.isDiscriminantProperty.get(considerNonUniformPrimitivePropDiscriminant);
+
+                if (typeof isDiscriminant === "undefined") {
+                    isDiscriminant = (((transientSymbol.links.checkFlags & CheckFlags.Discriminant) === CheckFlags.Discriminant)
+                        || !!(considerNonUniformPrimitivePropDiscriminant && (transientSymbol.links.checkFlags & CheckFlags.HasNonUniformType) && someType(propType, t => !!(t.flags & TypeFlags.Primitive))))
+                        && !isGenericType(propType);
+
+                    transientSymbol.links.isDiscriminantProperty.set(considerNonUniformPrimitivePropDiscriminant, isDiscriminant);
                 }
-                return !!(prop as TransientSymbol).links.isDiscriminantProperty;
+
+                return isDiscriminant;
             }
         }
         return false;
@@ -27299,7 +27312,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
     function findDiscriminantProperties(sourceProperties: Symbol[], target: Type): Symbol[] | undefined {
         let result: Symbol[] | undefined;
         for (const sourceProperty of sourceProperties) {
-            if (isDiscriminantProperty(target, sourceProperty.escapedName)) {
+            if (isDiscriminantProperty(target, sourceProperty.escapedName, /*considerNonUniformPrimitivePropDiscriminant*/ false)) {
                 if (result) {
                     result.push(sourceProperty);
                     continue;

src/compiler/types.ts

@@ -2756,7 +2756,7 @@ export interface ArrowFunction extends Expression, FunctionLikeDeclarationBase,
     readonly modifiers?: NodeArray<Modifier>;
     readonly equalsGreaterThanToken: EqualsGreaterThanToken;
     readonly body: ConciseBody;
-    readonly name: never;
+    readonly name?: never;
 }
 
 // The text property of a LiteralExpression stores the interpreted value of the literal in text form. For a StringLiteral,
@@ -6020,7 +6020,7 @@ export interface SymbolLinks {
     leftSpread?: Symbol;                        // Left source for synthetic spread property
     rightSpread?: Symbol;                       // Right source for synthetic spread property
     syntheticOrigin?: Symbol;                   // For a property on a mapped or spread type, points back to the original property
-    isDiscriminantProperty?: boolean;           // True if discriminant synthetic property
+    isDiscriminantProperty?: Map<boolean, boolean | undefined> // Key is a flag, value is true if discriminant synthetic property
     resolvedExports?: SymbolTable;              // Resolved exports of module or combined early- and late-bound static members of a class.
     resolvedMembers?: SymbolTable;              // Combined early- and late-bound members of a symbol
     exportsChecked?: boolean;                   // True if exports of external module have been checked

tests/baselines/reference/api/typescript.d.ts

@@ -4989,7 +4989,7 @@ declare namespace ts {
         readonly modifiers?: NodeArray<Modifier>;
         readonly equalsGreaterThanToken: EqualsGreaterThanToken;
         readonly body: ConciseBody;
-        readonly name: never;
+        readonly name?: never;
     }
     interface LiteralLikeNode extends Node {
         text: string;

tests/baselines/reference/narrowUnionOfObjectsByPrimitiveProperty.errors.txt

@@ -0,0 +1,128 @@
+narrowUnionOfObjectsByPrimitiveProperty.ts(62,1): error TS2322: Type '{ prop: string | number; other: never; }' is not assignable to type '{ prop: string; other: string; } | { prop: number; other: number; }'.
+  Type '{ prop: string | number; other: never; }' is not assignable to type '{ prop: number; other: number; }'.
+    Types of property 'prop' are incompatible.
+      Type 'string | number' is not assignable to type 'number'.
+        Type 'string' is not assignable to type 'number'.
+narrowUnionOfObjectsByPrimitiveProperty.ts(70,1): error TS2322: Type '{ prop: string | number; other: never; }' is not assignable to type '{ prop: string; other: string; } | { prop: number; other: number; }'.
+  Type '{ prop: string | number; other: never; }' is not assignable to type '{ prop: number; other: number; }'.
+    Types of property 'prop' are incompatible.
+      Type 'string | number' is not assignable to type 'number'.
+        Type 'string' is not assignable to type 'number'.
+narrowUnionOfObjectsByPrimitiveProperty.ts(96,32): error TS2339: Property 'label' does not exist on type 'never'.
+
+
+==== narrowUnionOfObjectsByPrimitiveProperty.ts (3 errors) ====
+    export {}
+
+    interface State<Type> {
+      state: Type;
+    }
+
+    interface UserName {
+      first: string;
+      last?: string;
+    }
+
+    const nameState = {} as {
+      value: string;
+      state: State<string>;
+    } | {
+      value: UserName;
+      state: State<UserName>;
+    }
+
+    if (typeof nameState.value === "string") {
+      nameState.state satisfies State<string>;
+    } else {
+      nameState.state satisfies State<UserName>;
+    }
+
+
+    declare const arr: [string, number] | [number, string];
+    if (typeof arr[0] === "string") {
+      arr[1] satisfies number;
+    } else {
+      arr[1] satisfies string;
+    }
+
+
+    function aStringOrANumber<T extends { a: string } | { a: number }>(param: T): T extends { a: string } ? string : T extends { a: number } ? number : never {
+      if (typeof param.a === "string") {
+        return param.a.repeat(3);
+      }
+      if (typeof param.a === "number") {
+        return Math.exp(param.a);
+      }
+      throw new Error()
+    }
+
+    aStringOrANumber({ a: "string" })
+    aStringOrANumber({ a: 42 })
+
+
+    // The following two tests ensure that the discriminativeness of property 'prop'
+    // is treated differently in assignability and narrowing, and that the discriminativeness is properly cached.
+    declare let obj: { prop: string, other: string } | { prop: number, other: number }
+
+    // Here, we first perform narrowing, but the subsequent assignability should not be affected.
+    // We expect an error there because of an incorrect value assigned to 'prop'.
+    // See contextualTypeWithUnionTypeObjectLiteral.ts
+    if(typeof obj.prop === "string") {
+      obj.other.repeat(3);
+    } else {
+      Math.exp(obj.other);
+    }
+
+    obj = { prop: Math.random() > 0.5 ? "whatever" : 42, other: "irrelevant" as never }
+    ~~~
+!!! error TS2322: Type '{ prop: string | number; other: never; }' is not assignable to type '{ prop: string; other: string; } | { prop: number; other: number; }'.
+!!! error TS2322:   Type '{ prop: string | number; other: never; }' is not assignable to type '{ prop: number; other: number; }'.
+!!! error TS2322:     Types of property 'prop' are incompatible.
+!!! error TS2322:       Type 'string | number' is not assignable to type 'number'.
+!!! error TS2322:         Type 'string' is not assignable to type 'number'.
+
+
+    declare let obj2: { prop: string, other: string } | { prop: number, other: number }
+
+    // Here, we first assign a value to 'obj2' and then perform narrowing.
+    // We expect an error here because of an incorrect value assigned to 'prop', like above,
+    // but the subsequent narrowing should not be affected by the assignability.
+    obj2 = { prop: Math.random() > 0.5 ? "whatever" : 42, other: "irrelevant" as never }
+    ~~~~
+!!! error TS2322: Type '{ prop: string | number; other: never; }' is not assignable to type '{ prop: string; other: string; } | { prop: number; other: number; }'.
+!!! error TS2322:   Type '{ prop: string | number; other: never; }' is not assignable to type '{ prop: number; other: number; }'.
+!!! error TS2322:     Types of property 'prop' are incompatible.
+!!! error TS2322:       Type 'string | number' is not assignable to type 'number'.
+!!! error TS2322:         Type 'string' is not assignable to type 'number'.
+
+    if(typeof obj2.prop === "string") {
+      obj2.other.repeat(3);
+    } else {
+      Math.exp(obj2.other);
+    }
+
+
+    interface ILocalizedString {
+        original: string;
+        value: string;
+    }
+
+    type Opt = ({
+        label: ILocalizedString;
+        alias?: string;
+    } | {
+        label: string;
+        alias: string;
+    })
+
+    declare const opt: Opt
+
+    if (typeof opt.label === 'string') {
+        const l = opt.label;
+        const a = opt.alias ?? opt.label;
+                                   ~~~~~
+!!! error TS2339: Property 'label' does not exist on type 'never'.
+    } else {
+        const l = opt.label;
+        const a = opt.alias ?? opt.label.original;
+    }

tests/baselines/reference/narrowUnionOfObjectsByPrimitiveProperty.js

@@ -0,0 +1,158 @@
+//// [tests/cases/compiler/narrowUnionOfObjectsByPrimitiveProperty.ts] ////
+
+//// [narrowUnionOfObjectsByPrimitiveProperty.ts]
+export {}
+
+interface State<Type> {
+  state: Type;
+}
+
+interface UserName {
+  first: string;
+  last?: string;
+}
+
+const nameState = {} as {
+  value: string;
+  state: State<string>;
+} | {
+  value: UserName;
+  state: State<UserName>;
+}
+
+if (typeof nameState.value === "string") {
+  nameState.state satisfies State<string>;
+} else {
+  nameState.state satisfies State<UserName>;
+}
+
+
+declare const arr: [string, number] | [number, string];
+if (typeof arr[0] === "string") {
+  arr[1] satisfies number;
+} else {
+  arr[1] satisfies string;
+}
+
+
+function aStringOrANumber<T extends { a: string } | { a: number }>(param: T): T extends { a: string } ? string : T extends { a: number } ? number : never {
+  if (typeof param.a === "string") {
+    return param.a.repeat(3);
+  }
+  if (typeof param.a === "number") {
+    return Math.exp(param.a);
+  }
+  throw new Error()
+}
+
+aStringOrANumber({ a: "string" })
+aStringOrANumber({ a: 42 })
+
+
+// The following two tests ensure that the discriminativeness of property 'prop'
+// is treated differently in assignability and narrowing, and that the discriminativeness is properly cached.
+declare let obj: { prop: string, other: string } | { prop: number, other: number }
+
+// Here, we first perform narrowing, but the subsequent assignability should not be affected.
+// We expect an error there because of an incorrect value assigned to 'prop'.
+// See contextualTypeWithUnionTypeObjectLiteral.ts
+if(typeof obj.prop === "string") {
+  obj.other.repeat(3);
+} else {
+  Math.exp(obj.other);
+}
+
+obj = { prop: Math.random() > 0.5 ? "whatever" : 42, other: "irrelevant" as never }
+
+
+declare let obj2: { prop: string, other: string } | { prop: number, other: number }
+
+// Here, we first assign a value to 'obj2' and then perform narrowing.
+// We expect an error here because of an incorrect value assigned to 'prop', like above,
+// but the subsequent narrowing should not be affected by the assignability.
+obj2 = { prop: Math.random() > 0.5 ? "whatever" : 42, other: "irrelevant" as never }
+
+if(typeof obj2.prop === "string") {
+  obj2.other.repeat(3);
+} else {
+  Math.exp(obj2.other);
+}
+
+
+interface ILocalizedString {
+    original: string;
+    value: string;
+}
+
+type Opt = ({
+    label: ILocalizedString;
+    alias?: string;
+} | {
+    label: string;
+    alias: string;
+})
+
+declare const opt: Opt
+
+if (typeof opt.label === 'string') {
+    const l = opt.label;
+    const a = opt.alias ?? opt.label;
+} else {
+    const l = opt.label;
+    const a = opt.alias ?? opt.label.original;
+}
+
+//// [narrowUnionOfObjectsByPrimitiveProperty.js]
+const nameState = {};
+if (typeof nameState.value === "string") {
+    nameState.state;
+}
+else {
+    nameState.state;
+}
+if (typeof arr[0] === "string") {
+    arr[1];
+}
+else {
+    arr[1];
+}
+function aStringOrANumber(param) {
+    if (typeof param.a === "string") {
+        return param.a.repeat(3);
+    }
+    if (typeof param.a === "number") {
+        return Math.exp(param.a);
+    }
+    throw new Error();
+}
+aStringOrANumber({ a: "string" });
+aStringOrANumber({ a: 42 });
+// Here, we first perform narrowing, but the subsequent assignability should not be affected.
+// We expect an error there because of an incorrect value assigned to 'prop'.
+// See contextualTypeWithUnionTypeObjectLiteral.ts
+if (typeof obj.prop === "string") {
+    obj.other.repeat(3);
+}
+else {
+    Math.exp(obj.other);
+}
+obj = { prop: Math.random() > 0.5 ? "whatever" : 42, other: "irrelevant" };
+// Here, we first assign a value to 'obj2' and then perform narrowing.
+// We expect an error here because of an incorrect value assigned to 'prop', like above,
+// but the subsequent narrowing should not be affected by the assignability.
+obj2 = { prop: Math.random() > 0.5 ? "whatever" : 42, other: "irrelevant" };
+if (typeof obj2.prop === "string") {
+    obj2.other.repeat(3);
+}
+else {
+    Math.exp(obj2.other);
+}
+if (typeof opt.label === 'string') {
+    const l = opt.label;
+    const a = opt.alias ?? opt.label;
+}
+else {
+    const l = opt.label;
+    const a = opt.alias ?? opt.label.original;
+}
+export {};