Skip to content

Commit b2518c6

Browse files
ahejlsbergahejlsberg
committed
Rename from TemplateType to TemplateLiteralType
1 parent 9c1f9fb commit b2518c6

File tree

2 files changed

+40
-40
lines changed

2 files changed

+40
-40
lines changed

‎src/compiler/checker.ts

Lines changed: 32 additions & 32 deletions
Original file line numberDiff line numberDiff line change
@@ -692,7 +692,7 @@ namespace ts {
692692
const intersectionTypes = new Map<string, Type>();
693693
const literalTypes = new Map<string, LiteralType>();
694694
const indexedAccessTypes = new Map<string, IndexedAccessType>();
695-
const templateTypes = new Map<string, TemplateType>();
695+
const templateLiteralTypes = new Map<string, TemplateLiteralType>();
696696
const substitutionTypes = new Map<string, SubstitutionType>();
697697
const evolvingArrayTypes: EvolvingArrayType[] = [];
698698
const undefinedProperties: SymbolTable = new Map();
@@ -4460,10 +4460,10 @@ namespace ts {
44604460
const indexTypeNode = typeToTypeNodeHelper(indexedType, context);
44614461
return factory.createTypeOperatorNode(SyntaxKind.KeyOfKeyword, indexTypeNode);
44624462
}
4463-
if (type.flags & TypeFlags.Template) {
4464-
const texts = (<TemplateType>type).texts;
4465-
const casings = (<TemplateType>type).casings;
4466-
const types = (<TemplateType>type).types;
4463+
if (type.flags & TypeFlags.TemplateLiteral) {
4464+
const texts = (<TemplateLiteralType>type).texts;
4465+
const casings = (<TemplateLiteralType>type).casings;
4466+
const types = (<TemplateLiteralType>type).types;
44674467
const templateHead = factory.createTemplateHead(texts[0]);
44684468
const templateSpans = factory.createNodeArray(
44694469
map(types, (t, i) => factory.createTemplateTypeSpan(
@@ -10767,7 +10767,7 @@ namespace ts {
1076710767
}
1076810768

1076910769
function getBaseConstraintOfType(type: Type): Type | undefined {
10770-
if (type.flags & (TypeFlags.InstantiableNonPrimitive | TypeFlags.UnionOrIntersection | TypeFlags.Template)) {
10770+
if (type.flags & (TypeFlags.InstantiableNonPrimitive | TypeFlags.UnionOrIntersection | TypeFlags.TemplateLiteral)) {
1077110771
const constraint = getResolvedBaseConstraint(<InstantiableType | UnionOrIntersectionType>type);
1077210772
return constraint !== noConstraintType && constraint !== circularConstraintType ? constraint : undefined;
1077310773
}
@@ -10861,10 +10861,10 @@ namespace ts {
1086110861
if (t.flags & TypeFlags.Index) {
1086210862
return keyofConstraintType;
1086310863
}
10864-
if (t.flags & TypeFlags.Template) {
10865-
const types = (<TemplateType>t).types;
10864+
if (t.flags & TypeFlags.TemplateLiteral) {
10865+
const types = (<TemplateLiteralType>t).types;
1086610866
const constraints = mapDefined(types, getBaseConstraint);
10867-
return constraints.length === types.length ? getTemplateType((<TemplateType>t).texts, (<TemplateType>t).casings, constraints) : stringType;
10867+
return constraints.length === types.length ? getTemplateLiteralType((<TemplateLiteralType>t).texts, (<TemplateLiteralType>t).casings, constraints) : stringType;
1086810868
}
1086910869
if (t.flags & TypeFlags.IndexedAccess) {
1087010870
const baseObjectType = getBaseConstraint((<IndexedAccessType>t).objectType);
@@ -13401,19 +13401,19 @@ namespace ts {
1340113401
function getTypeFromTemplateTypeNode(node: TemplateTypeNode) {
1340213402
const links = getNodeLinks(node);
1340313403
if (!links.resolvedType) {
13404-
links.resolvedType = getTemplateType(
13404+
links.resolvedType = getTemplateLiteralType(
1340513405
[node.head.text, ...map(node.templateSpans, span => span.literal.text)],
1340613406
map(node.templateSpans, span => span.casing),
1340713407
map(node.templateSpans, span => getTypeFromTypeNode(span.type)));
1340813408
}
1340913409
return links.resolvedType;
1341013410
}
1341113411

13412-
function getTemplateType(texts: readonly string[], casings: readonly TemplateCasing[], types: readonly Type[]): Type {
13412+
function getTemplateLiteralType(texts: readonly string[], casings: readonly TemplateCasing[], types: readonly Type[]): Type {
1341313413
const unionIndex = findIndex(types, t => !!(t.flags & (TypeFlags.Never | TypeFlags.Union)));
1341413414
if (unionIndex >= 0) {
1341513415
return checkCrossProductUnion(types) ?
13416-
mapType(types[unionIndex], t => getTemplateType(texts, casings, replaceElement(types, unionIndex, t))) :
13416+
mapType(types[unionIndex], t => getTemplateLiteralType(texts, casings, replaceElement(types, unionIndex, t))) :
1341713417
errorType;
1341813418
}
1341913419
const newTypes = [];
@@ -13442,9 +13442,9 @@ namespace ts {
1344213442
}
1344313443
newTexts.push(text);
1344413444
const id = `${getTypeListId(newTypes)}|${newCasings.join(",")}|${map(newTexts, t => t.length).join(",")}|${newTexts.join("")}`;
13445-
let type = templateTypes.get(id);
13445+
let type = templateLiteralTypes.get(id);
1344613446
if (!type) {
13447-
templateTypes.set(id, type = createTemplateType(newTexts, newCasings, newTypes));
13447+
templateLiteralTypes.set(id, type = createTemplateLiteralType(newTexts, newCasings, newTypes));
1344813448
}
1344913449
return type;
1345013450
}
@@ -13467,8 +13467,8 @@ namespace ts {
1346713467
return str;
1346813468
}
1346913469

13470-
function createTemplateType(texts: readonly string[], casings: readonly TemplateCasing[], types: readonly Type[]) {
13471-
const type = <TemplateType>createType(TypeFlags.Template);
13470+
function createTemplateLiteralType(texts: readonly string[], casings: readonly TemplateCasing[], types: readonly Type[]) {
13471+
const type = <TemplateLiteralType>createType(TypeFlags.TemplateLiteral);
1347213472
type.texts = texts;
1347313473
type.casings = casings;
1347413474
type.types = types;
@@ -13707,7 +13707,7 @@ namespace ts {
1370713707
}
1370813708
return !!((<UnionOrIntersectionType>type).objectFlags & ObjectFlags.IsGenericIndexType);
1370913709
}
13710-
return !!(type.flags & (TypeFlags.InstantiableNonPrimitive | TypeFlags.Index | TypeFlags.Template));
13710+
return !!(type.flags & (TypeFlags.InstantiableNonPrimitive | TypeFlags.Index | TypeFlags.TemplateLiteral));
1371113711
}
1371213712

1371313713
function isThisTypeParameter(type: Type): boolean {
@@ -14205,7 +14205,7 @@ namespace ts {
1420514205
}
1420614206

1420714207
function isEmptyObjectTypeOrSpreadsIntoEmptyObject(type: Type) {
14208-
return isEmptyObjectType(type) || !!(type.flags & (TypeFlags.Null | TypeFlags.Undefined | TypeFlags.BooleanLike | TypeFlags.NumberLike | TypeFlags.BigIntLike | TypeFlags.StringLike | TypeFlags.EnumLike | TypeFlags.NonPrimitive | TypeFlags.Index | TypeFlags.Template));
14208+
return isEmptyObjectType(type) || !!(type.flags & (TypeFlags.Null | TypeFlags.Undefined | TypeFlags.BooleanLike | TypeFlags.NumberLike | TypeFlags.BigIntLike | TypeFlags.StringLike | TypeFlags.EnumLike | TypeFlags.NonPrimitive | TypeFlags.Index | TypeFlags.TemplateLiteral));
1420914209
}
1421014210

1421114211
function isSinglePropertyAnonymousObjectType(type: Type) {
@@ -14291,7 +14291,7 @@ namespace ts {
1429114291
}
1429214292
return mapType(right, t => getSpreadType(left, t, symbol, objectFlags, readonly));
1429314293
}
14294-
if (right.flags & (TypeFlags.BooleanLike | TypeFlags.NumberLike | TypeFlags.BigIntLike | TypeFlags.StringLike | TypeFlags.EnumLike | TypeFlags.NonPrimitive | TypeFlags.Index | TypeFlags.Template)) {
14294+
if (right.flags & (TypeFlags.BooleanLike | TypeFlags.NumberLike | TypeFlags.BigIntLike | TypeFlags.StringLike | TypeFlags.EnumLike | TypeFlags.NonPrimitive | TypeFlags.Index | TypeFlags.TemplateLiteral)) {
1429514295
return left;
1429614296
}
1429714297

@@ -15091,8 +15091,8 @@ namespace ts {
1509115091
if (flags & TypeFlags.Index) {
1509215092
return getIndexType(instantiateType((<IndexType>type).type, mapper));
1509315093
}
15094-
if (flags & TypeFlags.Template) {
15095-
return getTemplateType((<TemplateType>type).texts, (<TemplateType>type).casings, instantiateTypes((<TemplateType>type).types, mapper));
15094+
if (flags & TypeFlags.TemplateLiteral) {
15095+
return getTemplateLiteralType((<TemplateLiteralType>type).texts, (<TemplateLiteralType>type).casings, instantiateTypes((<TemplateLiteralType>type).types, mapper));
1509615096
}
1509715097
if (flags & TypeFlags.IndexedAccess) {
1509815098
return getIndexedAccessType(instantiateType((<IndexedAccessType>type).objectType, mapper), instantiateType((<IndexedAccessType>type).indexType, mapper), /*accessNode*/ undefined, type.aliasSymbol, instantiateTypes(type.aliasTypeArguments, mapper));
@@ -17220,7 +17220,7 @@ namespace ts {
1722017220
return result;
1722117221
}
1722217222
}
17223-
else if (source.flags & TypeFlags.Template) {
17223+
else if (source.flags & TypeFlags.TemplateLiteral) {
1722417224
const constraint = getBaseConstraintOfType(source);
1722517225
if (constraint && (result = isRelatedTo(constraint, target, reportErrors))) {
1722617226
resetErrorInfo(saveErrorInfo);
@@ -19667,8 +19667,8 @@ namespace ts {
1966719667
inferFromTypes(sourceType, target);
1966819668
}
1966919669
}
19670-
else if (target.flags & TypeFlags.Template) {
19671-
inferToTemplateType(source, <TemplateType>target);
19670+
else if (target.flags & TypeFlags.TemplateLiteral) {
19671+
inferToTemplateLiteralType(source, <TemplateLiteralType>target);
1967219672
}
1967319673
else {
1967419674
source = getReducedType(source);
@@ -19948,10 +19948,10 @@ namespace ts {
1994819948
}
1994919949
}
1995019950

19951-
function inferToTemplateType(source: Type, target: TemplateType) {
19951+
function inferToTemplateLiteralType(source: Type, target: TemplateLiteralType) {
1995219952
if (source.flags & (TypeFlags.StringLike | TypeFlags.Index)) {
19953-
const matches = source.flags & TypeFlags.StringLiteral ? inferLiteralsFromTemplateType(<StringLiteralType>source, target) :
19954-
source.flags & TypeFlags.Template && arraysEqual((<TemplateType>source).texts, target.texts) && arraysEqual((<TemplateType>source).casings, target.casings)? (<TemplateType>source).types :
19953+
const matches = source.flags & TypeFlags.StringLiteral ? inferLiteralsFromTemplateLiteralType(<StringLiteralType>source, target) :
19954+
source.flags & TypeFlags.TemplateLiteral && arraysEqual((<TemplateLiteralType>source).texts, target.texts) && arraysEqual((<TemplateLiteralType>source).casings, target.casings)? (<TemplateLiteralType>source).types :
1995519955
undefined;
1995619956
const types = target.types;
1995719957
for (let i = 0; i < types.length; i++) {
@@ -19960,7 +19960,7 @@ namespace ts {
1996019960
}
1996119961
}
1996219962

19963-
function inferLiteralsFromTemplateType(source: StringLiteralType, target: TemplateType): Type[] | undefined {
19963+
function inferLiteralsFromTemplateLiteralType(source: StringLiteralType, target: TemplateLiteralType): Type[] | undefined {
1996419964
const value = source.value;
1996519965
const texts = target.texts;
1996619966
const lastIndex = texts.length - 1;
@@ -20146,7 +20146,7 @@ namespace ts {
2014620146

2014720147
function hasPrimitiveConstraint(type: TypeParameter): boolean {
2014820148
const constraint = getConstraintOfTypeParameter(type);
20149-
return !!constraint && maybeTypeOfKind(constraint.flags & TypeFlags.Conditional ? getDefaultConstraintOfConditionalType(constraint as ConditionalType) : constraint, TypeFlags.Primitive | TypeFlags.Index | TypeFlags.Template);
20149+
return !!constraint && maybeTypeOfKind(constraint.flags & TypeFlags.Conditional ? getDefaultConstraintOfConditionalType(constraint as ConditionalType) : constraint, TypeFlags.Primitive | TypeFlags.Index | TypeFlags.TemplateLiteral);
2015020150
}
2015120151

2015220152
function isObjectLiteralType(type: Type) {
@@ -26176,7 +26176,7 @@ namespace ts {
2617626176
else {
2617726177
const contextualType = getIndexedAccessType(restType, getLiteralType(i - index));
2617826178
const argType = checkExpressionWithContextualType(arg, contextualType, context, checkMode);
26179-
const hasPrimitiveContextualType = maybeTypeOfKind(contextualType, TypeFlags.Primitive | TypeFlags.Index | TypeFlags.Template);
26179+
const hasPrimitiveContextualType = maybeTypeOfKind(contextualType, TypeFlags.Primitive | TypeFlags.Index | TypeFlags.TemplateLiteral);
2618026180
types.push(hasPrimitiveContextualType ? getRegularTypeOfLiteralType(argType) : getWidenedLiteralType(argType));
2618126181
flags.push(ElementFlags.Required);
2618226182
}
@@ -29192,7 +29192,7 @@ namespace ts {
2919229192
// and the right operand to be of type Any, an object type, or a type parameter type.
2919329193
// The result is always of the Boolean primitive type.
2919429194
if (!(allTypesAssignableToKind(leftType, TypeFlags.StringLike | TypeFlags.NumberLike | TypeFlags.ESSymbolLike) ||
29195-
isTypeAssignableToKind(leftType, TypeFlags.Index | TypeFlags.Template | TypeFlags.TypeParameter))) {
29195+
isTypeAssignableToKind(leftType, TypeFlags.Index | TypeFlags.TemplateLiteral | TypeFlags.TypeParameter))) {
2919629196
error(left, Diagnostics.The_left_hand_side_of_an_in_expression_must_be_of_type_any_string_number_or_symbol);
2919729197
}
2919829198
if (!allTypesAssignableToKind(rightType, TypeFlags.NonPrimitive | TypeFlags.InstantiableNonPrimitive)) {
@@ -30141,7 +30141,7 @@ namespace ts {
3014130141
}
3014230142
// If the contextual type is a literal of a particular primitive type, we consider this a
3014330143
// literal context for all literals of that primitive type.
30144-
return !!(contextualType.flags & (TypeFlags.StringLiteral | TypeFlags.Index | TypeFlags.Template) && maybeTypeOfKind(candidateType, TypeFlags.StringLiteral) ||
30144+
return !!(contextualType.flags & (TypeFlags.StringLiteral | TypeFlags.Index | TypeFlags.TemplateLiteral) && maybeTypeOfKind(candidateType, TypeFlags.StringLiteral) ||
3014530145
contextualType.flags & TypeFlags.NumberLiteral && maybeTypeOfKind(candidateType, TypeFlags.NumberLiteral) ||
3014630146
contextualType.flags & TypeFlags.BigIntLiteral && maybeTypeOfKind(candidateType, TypeFlags.BigIntLiteral) ||
3014730147
contextualType.flags & TypeFlags.BooleanLiteral && maybeTypeOfKind(candidateType, TypeFlags.BooleanLiteral) ||

‎src/compiler/types.ts

Lines changed: 8 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -2141,21 +2141,21 @@ namespace ts {
21412141

21422142
export interface TemplateHead extends TemplateLiteralLikeNode {
21432143
readonly kind: SyntaxKind.TemplateHead;
2144-
readonly parent: TemplateExpression;
2144+
readonly parent: TemplateExpression | TemplateTypeNode;
21452145
/* @internal */
21462146
templateFlags?: TokenFlags;
21472147
}
21482148

21492149
export interface TemplateMiddle extends TemplateLiteralLikeNode {
21502150
readonly kind: SyntaxKind.TemplateMiddle;
2151-
readonly parent: TemplateSpan;
2151+
readonly parent: TemplateSpan | TemplateTypeSpan;
21522152
/* @internal */
21532153
templateFlags?: TokenFlags;
21542154
}
21552155

21562156
export interface TemplateTail extends TemplateLiteralLikeNode {
21572157
readonly kind: SyntaxKind.TemplateTail;
2158-
readonly parent: TemplateSpan;
2158+
readonly parent: TemplateSpan | TemplateTypeSpan;
21592159
/* @internal */
21602160
templateFlags?: TokenFlags;
21612161
}
@@ -4872,7 +4872,7 @@ namespace ts {
48724872
Conditional = 1 << 24, // T extends U ? X : Y
48734873
Substitution = 1 << 25, // Type parameter substitution
48744874
NonPrimitive = 1 << 26, // intrinsic object type
4875-
Template = 1 << 27, // String template type
4875+
TemplateLiteral = 1 << 27, // Template literal type
48764876

48774877
/* @internal */
48784878
AnyOrUnknown = Any | Unknown,
@@ -4890,7 +4890,7 @@ namespace ts {
48904890
Intrinsic = Any | Unknown | String | Number | BigInt | Boolean | BooleanLiteral | ESSymbol | Void | Undefined | Null | Never | NonPrimitive,
48914891
/* @internal */
48924892
Primitive = String | Number | BigInt | Boolean | Enum | EnumLiteral | ESSymbol | Void | Undefined | Null | Literal | UniqueESSymbol,
4893-
StringLike = String | StringLiteral | Template,
4893+
StringLike = String | StringLiteral | TemplateLiteral,
48944894
NumberLike = Number | NumberLiteral | Enum,
48954895
BigIntLike = BigInt | BigIntLiteral,
48964896
BooleanLike = Boolean | BooleanLiteral,
@@ -4903,15 +4903,15 @@ namespace ts {
49034903
StructuredType = Object | Union | Intersection,
49044904
TypeVariable = TypeParameter | IndexedAccess,
49054905
InstantiableNonPrimitive = TypeVariable | Conditional | Substitution,
4906-
InstantiablePrimitive = Index | Template,
4906+
InstantiablePrimitive = Index | TemplateLiteral,
49074907
Instantiable = InstantiableNonPrimitive | InstantiablePrimitive,
49084908
StructuredOrInstantiable = StructuredType | Instantiable,
49094909
/* @internal */
49104910
ObjectFlagsType = Any | Nullable | Never | Object | Union | Intersection,
49114911
/* @internal */
49124912
Simplifiable = IndexedAccess | Conditional,
49134913
/* @internal */
4914-
Substructure = Object | Union | Intersection | Index | IndexedAccess | Conditional | Substitution | Template,
4914+
Substructure = Object | Union | Intersection | Index | IndexedAccess | Conditional | Substitution | TemplateLiteral,
49154915
// 'Narrowable' types are types where narrowing actually narrows.
49164916
// This *should* be every type other than null, undefined, void, and never
49174917
Narrowable = Any | Unknown | StructuredOrInstantiable | StringLike | NumberLike | BigIntLike | BooleanLike | ESSymbol | UniqueESSymbol | NonPrimitive,
@@ -5353,7 +5353,7 @@ namespace ts {
53535353
combinedMapper?: TypeMapper;
53545354
}
53555355

5356-
export interface TemplateType extends InstantiableType {
5356+
export interface TemplateLiteralType extends InstantiableType {
53575357
texts: readonly string[]; // Always one element longer than casings/types
53585358
casings: readonly TemplateCasing[]; // Always at least one element
53595359
types: readonly Type[]; // Always at least one element

0 commit comments

Comments
 (0)