type.flags & (TypeFlags.BooleanLiteral | TypeFlags.Nullable) ? (<IntrinsicType>type).intrinsicName :

return !!(type.flags & (TypeFlags.Any | TypeFlags.String | TypeFlags.Number | TypeFlags.BigInt));

else if (target.flags & TypeFlags.TemplateLiteral) {

const result = inferTypesFromTemplateLiteralType(source, target as TemplateLiteralType);

if (result && every(result, (r, i) => isValidTypeForTemplateLiteralPlaceholder(r, (target as TemplateLiteralType).types[i]))) {

return Ternary.True;

function isValidTypeForTemplateLiteralPlaceholder(source: Type, target: Type): boolean {

if (source === target || target.flags & (TypeFlags.Any | TypeFlags.String)) {

return true;

}

if (source.flags & TypeFlags.StringLiteral) {

const value = (<StringLiteralType>source).value;

return !!(target.flags & TypeFlags.Number && value !== "" && isFinite(+value) ||

target.flags & TypeFlags.BigInt && value !== "" && isValidBigIntString(value) ||

target.flags & (TypeFlags.BooleanLiteral | TypeFlags.Nullable) && value === (<IntrinsicType>target).intrinsicName);

}

if (source.flags & TypeFlags.TemplateLiteral) {

const texts = (<TemplateLiteralType>source).texts;

return texts.length === 2 && texts[0] === "" && texts[1] === "" && isTypeAssignableTo((<TemplateLiteralType>source).types[0], target);

}

return isTypeAssignableTo(source, target);

}

function inferTypesFromTemplateLiteralType(source: Type, target: TemplateLiteralType): Type[] | undefined {

return source.flags & TypeFlags.StringLiteral ? inferFromLiteralPartsToTemplateLiteral([(<StringLiteralType>source).value], emptyArray, target) :

source.flags & TypeFlags.TemplateLiteral ?

arraysEqual((<TemplateLiteralType>source).texts, target.texts) ? map((<TemplateLiteralType>source).types, getStringLikeTypeForType) :

inferFromLiteralPartsToTemplateLiteral((<TemplateLiteralType>source).texts, (<TemplateLiteralType>source).types, target) :

undefined;

}

function getStringLikeTypeForType(type: Type) {

return type.flags & (TypeFlags.Any | TypeFlags.StringLike) ? type : getTemplateLiteralType(["", ""], [type]);

}

// This function infers from the text parts and type parts of a source literal to a target template literal. The number

// of text parts is always one more than the number of type parts, and a source string literal is treated as a source

// with one text part and zero type parts. The function returns an array of inferred string or template literal types

// corresponding to the placeholders in the target template literal, or undefined if the source doesn't match the target.

//

// We first check that the starting source text part matches the starting target text part, and that the ending source

// text part ends matches the ending target text part. We then iterate through the remaining target text parts, finding

// a match for each in the source and inferring string or template literal types created from the segments of the source

// that occur between the matches. During this iteration, seg holds the index of the current text part in the sourceTexts

// array and pos holds the current character position in the current text part.

//

// Consider inference from type `<<${string}>.<${number}-${number}>>` to type `<${string}.${string}>`, i.e.

// sourceTexts = ['<<', '>.<', '-', '>>']

// sourceTypes = [string, number, number]

// target.texts = ['<', '.', '>']

// We first match '<' in the target to the start of '<<' in the source and '>' in the target to the end of '>>' in

// the source. The first match for the '.' in target occurs at character 1 in the source text part at index 1, and thus

// the first inference is the template literal type `<${string}>`. The remainder of the source makes up the second

// inference, the template literal type `<${number}-${number}>`.

function inferFromLiteralPartsToTemplateLiteral(sourceTexts: readonly string[], sourceTypes: readonly Type[], target: TemplateLiteralType): Type[] | undefined {

const lastSourceIndex = sourceTexts.length - 1;

const sourceStartText = sourceTexts[0];

const sourceEndText = sourceTexts[lastSourceIndex];

const targetTexts = target.texts;

const lastTargetIndex = targetTexts.length - 1;

const targetStartText = targetTexts[0];

const targetEndText = targetTexts[lastTargetIndex];

if (lastSourceIndex === 0 && sourceStartText.length < targetStartText.length + targetEndText.length ||

!sourceStartText.startsWith(targetStartText) || !sourceEndText.endsWith(targetEndText)) return undefined;

const remainingEndText = sourceEndText.slice(0, sourceEndText.length - targetEndText.length);

const matches: Type[] = [];

let seg = 0;

let pos = targetStartText.length;

for (let i = 1; i < lastTargetIndex; i++) {

const delim = targetTexts[i];

if (delim.length > 0) {

let s = seg;

let p = pos;

while (true) {

p = getSourceText(s).indexOf(delim, p);

if (p >= 0) break;

s++;

if (s === sourceTexts.length) return undefined;

p = 0;

}

addMatch(s, p);

pos += delim.length;

}

else if (pos < getSourceText(seg).length) {

addMatch(seg, pos + 1);

}

else if (seg < lastSourceIndex) {

addMatch(seg + 1, 0);

}

else {

return undefined;

}

}

addMatch(lastSourceIndex, getSourceText(lastSourceIndex).length);

function getSourceText(index: number) {

return index < lastSourceIndex ? sourceTexts[index] : remainingEndText;

}

function addMatch(s: number, p: number) {

const matchType = s === seg ?

getLiteralType(getSourceText(s).slice(pos, p)) :

getTemplateLiteralType(

[sourceTexts[seg].slice(pos), ...sourceTexts.slice(seg + 1, s), getSourceText(s).slice(0, p)],

sourceTypes.slice(seg, s));

matches.push(matchType);

seg = s;

pos = p;

}

const matches = inferTypesFromTemplateLiteralType(source, target);

tests/cases/conformance/types/literal/templateLiteralTypes3.ts(20,19): error TS2345: Argument of type 'string' is not assignable to parameter of type 'never'.

tests/cases/conformance/types/literal/templateLiteralTypes3.ts(57,5): error TS2322: Type '"hello"' is not assignable to type '`*${string}*`'.

tests/cases/conformance/types/literal/templateLiteralTypes3.ts(69,5): error TS2322: Type '"123"' is not assignable to type '`*${number}*`'.

tests/cases/conformance/types/literal/templateLiteralTypes3.ts(71,5): error TS2322: Type '"**123**"' is not assignable to type '`*${number}*`'.

tests/cases/conformance/types/literal/templateLiteralTypes3.ts(72,5): error TS2322: Type '`*${string}*`' is not assignable to type '`*${number}*`'.

tests/cases/conformance/types/literal/templateLiteralTypes3.ts(74,5): error TS2322: Type '"*false*" | "*true*"' is not assignable to type '`*${number}*`'.

Type '"*false*"' is not assignable to type '`*${number}*`'.

==== tests/cases/conformance/types/literal/templateLiteralTypes3.ts (6 errors) ====

// Inference from template literal type to template literal type

type Foo1<T> = T extends `*${infer U}*` ? U : never;

type T01 = Foo1<'hello'>;

type T02 = Foo1<'*hello*'>;

type T03 = Foo1<'**hello**'>;

type T04 = Foo1<`*${string}*`>;

type T05 = Foo1<`*${number}*`>;

type T06 = Foo1<`*${bigint}*`>;

type T07 = Foo1<`*${any}*`>;

type T08 = Foo1<`**${string}**`>;

type T09 = Foo1<`**${string}**${string}**`>;

type T10 = Foo1<`**${'a' | 'b' | 'c'}**`>;

type T11 = Foo1<`**${boolean}**${boolean}**`>;

declare function foo1<V extends string>(arg: `*${V}*`): V;

function f1<T extends string>(s: string, n: number, b: boolean, t: T) {

let x1 = foo1('hello'); // Error

~~~~~~~

!!! error TS2345: Argument of type 'string' is not assignable to parameter of type 'never'.

let x2 = foo1('*hello*');

let x3 = foo1('**hello**');

let x4 = foo1(`*${s}*` as const);

let x5 = foo1(`*${n}*` as const);

let x6 = foo1(`*${b}*` as const);

let x7 = foo1(`*${t}*` as const);

let x8 = foo1(`**${s}**` as const);

}

// Inference to a placeholder immediately followed by another placeholder infers a single

// character or placeholder from the source.

type Parts<T> =

T extends '' ? [] :

T extends `${infer Head}${infer Tail}` ? [Head, ...Parts<Tail>] :

never;

type T20 = Parts<`abc`>;

type T21 = Parts<`*${string}*`>;

type T22 = Parts<`*${number}*`>;

type T23 = Parts<`*${number}*${string}*${bigint}*`>;

function f2() {

let x: `${number}.${number}.${number}`;

x = '1.1.1';

x = '1.1.1' as `1.1.${number}`;

x = '1.1.1' as `1.${number}.1`;

x = '1.1.1' as `1.${number}.${number}`;

x = '1.1.1' as `${number}.1.1`;

x = '1.1.1' as `${number}.1.${number}`;

x = '1.1.1' as `${number}.${number}.1`;

x = '1.1.1' as `${number}.${number}.${number}`;

}

function f3<T extends string>(s: string, n: number, b: boolean, t: T) {

let x: `*${string}*`;

x = 'hello'; // Error

~

!!! error TS2322: Type '"hello"' is not assignable to type '`*${string}*`'.

x = '*hello*';

x = '**hello**';

x = `*${s}*` as const;

x = `*${n}*` as const;

x = `*${b}*` as const;

x = `*${t}*` as const;

x = `**${s}**` as const;

}

function f4<T extends number>(s: string, n: number, b: boolean, t: T) {

let x: `*${number}*`;

x = '123'; // Error

~

!!! error TS2322: Type '"123"' is not assignable to type '`*${number}*`'.

x = '*123*';

x = '**123**'; // Error

~

!!! error TS2322: Type '"**123**"' is not assignable to type '`*${number}*`'.

x = `*${s}*` as const; // Error

~

!!! error TS2322: Type '`*${string}*`' is not assignable to type '`*${number}*`'.

x = `*${n}*` as const;

x = `*${b}*` as const; // Error

~

!!! error TS2322: Type '"*false*" | "*true*"' is not assignable to type '`*${number}*`'.

!!! error TS2322: Type '"*false*"' is not assignable to type '`*${number}*`'.

x = `*${t}*` as const;

}

// Repro from #43060

type A<T> = T extends `${infer U}.${infer V}` ? U | V : never

type B = A<`test.1024`>; // "test" | "1024"

type C = A<`test.${number}`>; // "test" | `${number}`

type D<T> = T extends `${infer U}.${number}` ? U : never

type E = D<`test.1024`>; // "test"

type F = D<`test.${number}`>; // "test"

type G<T> = T extends `${infer U}.${infer V}` ? U | V : never

type H = G<`test.hoge`>; // "test" | "hoge"

type I = G<`test.${string}`>; // string ("test" | string reduces to string)

type J<T> = T extends `${infer U}.${string}` ? U : never

type K = J<`test.hoge`>; // "test"

type L = J<`test.${string}`>; // "test""

// Repro from #43243

type Templated = `${string} ${string}`;

const value1: string = "abc";

const templated1: Templated = `${value1} abc` as const;

// Type '`${string} abc`' is not assignable to type '`${string} ${string}`'.

const value2 = "abc";

const templated2: Templated = `${value2} abc` as const;