Apply isLiteralContextualType recursively for unions and intersections.

Fixes microsoft#19632. The issue was isLiteralContextualType was only checking
for type parameters that extended a literal base type at the top level.
It was already recursively checking the constituents of unions and
intersections but it did so using maybeTypeOfKind which only compared
type flags matching literal or index.

Also adds a test case that failed before this change and succeeds now.

Author: kpdonn

src/compiler/checker.ts

@@ -18458,7 +18458,17 @@ namespace ts {
                     }
                     contextualType = constraint;
                 }
-                return maybeTypeOfKind(contextualType, (TypeFlags.Literal | TypeFlags.Index));
+                if (contextualType.flags & (TypeFlags.Literal | TypeFlags.Index)) {
+                    return true;
+                }
+                if (contextualType.flags & TypeFlags.UnionOrIntersection) {
+                    const types = (<UnionOrIntersectionType>contextualType).types;
+                    for (const t of types) {
+                        if (isLiteralContextualType(t)) {
+                            return true;
+                        }
+                    }
+                }
             }
             return false;
         }

tests/baselines/reference/genericCallStringLiteralUnionNested.js

@@ -0,0 +1,7 @@
+//// [genericCallStringLiteralUnionNested.ts]
+declare function nestedUnion<A extends string>(a: { fields: A | A[] }): Record<A, string>;
+const result: {z: string} = nestedUnion({ fields: "z" });
+
+
+//// [genericCallStringLiteralUnionNested.js]
+var result = nestedUnion({ fields: "z" });

tests/baselines/reference/genericCallStringLiteralUnionNested.symbols

@@ -0,0 +1,17 @@
+=== tests/cases/compiler/genericCallStringLiteralUnionNested.ts ===
+declare function nestedUnion<A extends string>(a: { fields: A | A[] }): Record<A, string>;
+>nestedUnion : Symbol(nestedUnion, Decl(genericCallStringLiteralUnionNested.ts, 0, 0))
+>A : Symbol(A, Decl(genericCallStringLiteralUnionNested.ts, 0, 29))
+>a : Symbol(a, Decl(genericCallStringLiteralUnionNested.ts, 0, 47))
+>fields : Symbol(fields, Decl(genericCallStringLiteralUnionNested.ts, 0, 51))
+>A : Symbol(A, Decl(genericCallStringLiteralUnionNested.ts, 0, 29))
+>A : Symbol(A, Decl(genericCallStringLiteralUnionNested.ts, 0, 29))
+>Record : Symbol(Record, Decl(lib.d.ts, --, --))
+>A : Symbol(A, Decl(genericCallStringLiteralUnionNested.ts, 0, 29))
+
+const result: {z: string} = nestedUnion({ fields: "z" });
+>result : Symbol(result, Decl(genericCallStringLiteralUnionNested.ts, 1, 5))
+>z : Symbol(z, Decl(genericCallStringLiteralUnionNested.ts, 1, 15))
+>nestedUnion : Symbol(nestedUnion, Decl(genericCallStringLiteralUnionNested.ts, 0, 0))
+>fields : Symbol(fields, Decl(genericCallStringLiteralUnionNested.ts, 1, 41))
+

tests/baselines/reference/genericCallStringLiteralUnionNested.types

@@ -0,0 +1,20 @@
+=== tests/cases/compiler/genericCallStringLiteralUnionNested.ts ===
+declare function nestedUnion<A extends string>(a: { fields: A | A[] }): Record<A, string>;
+>nestedUnion : <A extends string>(a: { fields: A | A[]; }) => Record<A, string>
+>A : A
+>a : { fields: A | A[]; }
+>fields : A | A[]
+>A : A
+>A : A
+>Record : Record<K, T>
+>A : A
+
+const result: {z: string} = nestedUnion({ fields: "z" });
+>result : { z: string; }
+>z : string
+>nestedUnion({ fields: "z" }) : Record<"z", string>
+>nestedUnion : <A extends string>(a: { fields: A | A[]; }) => Record<A, string>
+>{ fields: "z" } : { fields: "z"; }
+>fields : string
+>"z" : "z"
+

tests/cases/compiler/genericCallStringLiteralUnionNested.ts

@@ -0,0 +1,2 @@
+declare function nestedUnion<A extends string>(a: { fields: A | A[] }): Record<A, string>;
+const result: {z: string} = nestedUnion({ fields: "z" });