mirror of
https://github.com/microsoft/TypeScript.git
synced 2026-11-18 20:11:14 +00:00
Revert changes for template literal types, keeping tests. (#42588)
* Revert changes for template literal types, keeping tests. * Update Baselines and/or Applied Lint Fixes Co-authored-by: TypeScript Bot <typescriptbot@microsoft.com>
This commit is contained in:
1 parent
654975481f
commit
cce4bfbc7c
205 files changed
+1217
-1159
No files matched your search
+28
-35
@@ -13371,7 +13371,7 @@ namespace ts {
|
||||
i--;
|
||||
const t = types[i];
|
||||
const remove =
|
||||
t.flags & TypeFlags.StringLikeLiteral && includes & TypeFlags.String ||
|
||||
t.flags & TypeFlags.StringLiteral && includes & TypeFlags.String ||
|
||||
t.flags & TypeFlags.NumberLiteral && includes & TypeFlags.Number ||
|
||||
t.flags & TypeFlags.BigIntLiteral && includes & TypeFlags.BigInt ||
|
||||
t.flags & TypeFlags.UniqueESSymbol && includes & TypeFlags.ESSymbol ||
|
||||
@@ -13442,7 +13442,7 @@ namespace ts {
|
||||
}
|
||||
switch (unionReduction) {
|
||||
case UnionReduction.Literal:
|
||||
if (includes & (TypeFlags.FreshableLiteral | TypeFlags.UniqueESSymbol)) {
|
||||
if (includes & (TypeFlags.Literal | TypeFlags.UniqueESSymbol)) {
|
||||
removeRedundantLiteralTypes(typeSet, includes);
|
||||
}
|
||||
if (includes & TypeFlags.StringLiteral && includes & TypeFlags.TemplateLiteral) {
|
||||
@@ -14041,7 +14041,6 @@ namespace ts {
|
||||
let type = templateLiteralTypes.get(id);
|
||||
if (!type) {
|
||||
templateLiteralTypes.set(id, type = createTemplateLiteralType(newTexts, newTypes));
|
||||
type.regularType = type;
|
||||
}
|
||||
return type;
|
||||
|
||||
@@ -15098,28 +15097,26 @@ namespace ts {
|
||||
}
|
||||
|
||||
function getFreshTypeOfLiteralType(type: Type): Type {
|
||||
if (type.flags & TypeFlags.FreshableLiteral) {
|
||||
if (!(<FreshableLiteralType>type).freshType) {
|
||||
const freshType = type.flags & TypeFlags.TemplateLiteral ?
|
||||
createTemplateLiteralType((<TemplateLiteralType>type).texts, (<TemplateLiteralType>type).types) :
|
||||
createLiteralType(type.flags, (<LiteralType>type).value, (<LiteralType>type).symbol);
|
||||
freshType.regularType = <FreshableLiteralType>type;
|
||||
if (type.flags & TypeFlags.Literal) {
|
||||
if (!(<LiteralType>type).freshType) {
|
||||
const freshType = createLiteralType(type.flags, (<LiteralType>type).value, (<LiteralType>type).symbol);
|
||||
freshType.regularType = <LiteralType>type;
|
||||
freshType.freshType = freshType;
|
||||
(<FreshableLiteralType>type).freshType = freshType;
|
||||
(<LiteralType>type).freshType = freshType;
|
||||
}
|
||||
return (<FreshableLiteralType>type).freshType;
|
||||
return (<LiteralType>type).freshType;
|
||||
}
|
||||
return type;
|
||||
}
|
||||
|
||||
function getRegularTypeOfLiteralType(type: Type): Type {
|
||||
return type.flags & TypeFlags.FreshableLiteral ? (<FreshableLiteralType>type).regularType :
|
||||
return type.flags & TypeFlags.Literal ? (<LiteralType>type).regularType :
|
||||
type.flags & TypeFlags.Union ? ((<UnionType>type).regularType || ((<UnionType>type).regularType = mapType(type, getRegularTypeOfLiteralType) as UnionType)) :
|
||||
type;
|
||||
}
|
||||
|
||||
function isFreshLiteralType(type: Type) {
|
||||
return !!(type.flags & TypeFlags.FreshableLiteral) && (<FreshableLiteralType>type).freshType === type;
|
||||
return !!(type.flags & TypeFlags.Literal) && (<LiteralType>type).freshType === type;
|
||||
}
|
||||
|
||||
function getLiteralType(value: string): StringLiteralType;
|
||||
@@ -18030,20 +18027,17 @@ namespace ts {
|
||||
}
|
||||
}
|
||||
else if (source.flags & TypeFlags.TemplateLiteral) {
|
||||
if (target.flags & TypeFlags.TemplateLiteral) {
|
||||
if ((source as TemplateLiteralType).texts.length === (target as TemplateLiteralType).texts.length &&
|
||||
(source as TemplateLiteralType).types.length === (target as TemplateLiteralType).types.length &&
|
||||
every((source as TemplateLiteralType).texts, (t, i) => t === (target as TemplateLiteralType).texts[i]) &&
|
||||
every((instantiateType(source, makeFunctionTypeMapper(reportUnreliableMarkers)) as TemplateLiteralType).types, (t, i) => !!((target as TemplateLiteralType).types[i].flags & (TypeFlags.Any | TypeFlags.String)) || !!isRelatedTo(t, (target as TemplateLiteralType).types[i], /*reportErrors*/ false))) {
|
||||
return Ternary.True;
|
||||
}
|
||||
if (target.flags & TypeFlags.TemplateLiteral &&
|
||||
(source as TemplateLiteralType).texts.length === (target as TemplateLiteralType).texts.length &&
|
||||
(source as TemplateLiteralType).types.length === (target as TemplateLiteralType).types.length &&
|
||||
every((source as TemplateLiteralType).texts, (t, i) => t === (target as TemplateLiteralType).texts[i]) &&
|
||||
every((instantiateType(source, makeFunctionTypeMapper(reportUnreliableMarkers)) as TemplateLiteralType).types, (t, i) => !!((target as TemplateLiteralType).types[i].flags & (TypeFlags.Any | TypeFlags.String)) || !!isRelatedTo(t, (target as TemplateLiteralType).types[i], /*reportErrors*/ false))) {
|
||||
return Ternary.True;
|
||||
}
|
||||
else {
|
||||
const constraint = getBaseConstraintOfType(source);
|
||||
if (result = isRelatedTo(constraint && constraint !== source ? constraint : stringType, target, reportErrors)) {
|
||||
resetErrorInfo(saveErrorInfo);
|
||||
return result;
|
||||
}
|
||||
const constraint = getBaseConstraintOfType(source);
|
||||
if (constraint && constraint !== source && (result = isRelatedTo(constraint, target, reportErrors))) {
|
||||
resetErrorInfo(saveErrorInfo);
|
||||
return result;
|
||||
}
|
||||
}
|
||||
else if (source.flags & TypeFlags.StringMapping) {
|
||||
@@ -19538,7 +19532,7 @@ namespace ts {
|
||||
|
||||
function getBaseTypeOfLiteralType(type: Type): Type {
|
||||
return type.flags & TypeFlags.EnumLiteral ? getBaseTypeOfEnumLiteralType(<LiteralType>type) :
|
||||
type.flags & TypeFlags.StringLikeLiteral ? stringType :
|
||||
type.flags & TypeFlags.StringLiteral ? stringType :
|
||||
type.flags & TypeFlags.NumberLiteral ? numberType :
|
||||
type.flags & TypeFlags.BigIntLiteral ? bigintType :
|
||||
type.flags & TypeFlags.BooleanLiteral ? booleanType :
|
||||
@@ -19548,7 +19542,7 @@ namespace ts {
|
||||
|
||||
function getWidenedLiteralType(type: Type): Type {
|
||||
return type.flags & TypeFlags.EnumLiteral && isFreshLiteralType(type) ? getBaseTypeOfEnumLiteralType(<LiteralType>type) :
|
||||
type.flags & TypeFlags.StringLikeLiteral && isFreshLiteralType(type) ? stringType :
|
||||
type.flags & TypeFlags.StringLiteral && isFreshLiteralType(type) ? stringType :
|
||||
type.flags & TypeFlags.NumberLiteral && isFreshLiteralType(type) ? numberType :
|
||||
type.flags & TypeFlags.BigIntLiteral && isFreshLiteralType(type) ? bigintType :
|
||||
type.flags & TypeFlags.BooleanLiteral && isFreshLiteralType(type) ? booleanType :
|
||||
@@ -21042,7 +21036,7 @@ namespace ts {
|
||||
}
|
||||
|
||||
function isTypeOrBaseIdenticalTo(s: Type, t: Type) {
|
||||
return isTypeIdenticalTo(s, t) || !!(t.flags & TypeFlags.String && s.flags & TypeFlags.StringLikeLiteral || t.flags & TypeFlags.Number && s.flags & TypeFlags.NumberLiteral);
|
||||
return isTypeIdenticalTo(s, t) || !!(t.flags & TypeFlags.String && s.flags & TypeFlags.StringLiteral || t.flags & TypeFlags.Number && s.flags & TypeFlags.NumberLiteral);
|
||||
}
|
||||
|
||||
function isTypeCloselyMatchedBy(s: Type, t: Type) {
|
||||
@@ -31300,7 +31294,7 @@ namespace ts {
|
||||
texts.push(span.literal.text);
|
||||
types.push(isTypeAssignableTo(type, templateConstraintType) ? type : stringType);
|
||||
}
|
||||
return getFreshTypeOfLiteralType(getTemplateLiteralType(texts, types));
|
||||
return isConstContext(node) ? getTemplateLiteralType(texts, types) : stringType;
|
||||
}
|
||||
|
||||
function getContextNode(node: Expression): Node {
|
||||
@@ -31321,7 +31315,7 @@ namespace ts {
|
||||
// We strip literal freshness when an appropriate contextual type is present such that contextually typed
|
||||
// literals always preserve their literal types (otherwise they might widen during type inference). An alternative
|
||||
// here would be to not mark contextually typed literals as fresh in the first place.
|
||||
const result = maybeTypeOfKind(type, TypeFlags.FreshableLiteral) && isLiteralOfContextualType(type, instantiateContextualType(contextualType, node)) ?
|
||||
const result = maybeTypeOfKind(type, TypeFlags.Literal) && isLiteralOfContextualType(type, instantiateContextualType(contextualType, node)) ?
|
||||
getRegularTypeOfLiteralType(type) : type;
|
||||
return result;
|
||||
}
|
||||
@@ -31411,7 +31405,7 @@ namespace ts {
|
||||
// this a literal context for literals of that primitive type. For example, given a
|
||||
// type parameter 'T extends string', infer string literal types for T.
|
||||
const constraint = getBaseConstraintOfType(contextualType) || unknownType;
|
||||
return maybeTypeOfKind(constraint, TypeFlags.String) && maybeTypeOfKind(candidateType, TypeFlags.StringLikeLiteral) ||
|
||||
return maybeTypeOfKind(constraint, TypeFlags.String) && maybeTypeOfKind(candidateType, TypeFlags.StringLiteral) ||
|
||||
maybeTypeOfKind(constraint, TypeFlags.Number) && maybeTypeOfKind(candidateType, TypeFlags.NumberLiteral) ||
|
||||
maybeTypeOfKind(constraint, TypeFlags.BigInt) && maybeTypeOfKind(candidateType, TypeFlags.BigIntLiteral) ||
|
||||
maybeTypeOfKind(constraint, TypeFlags.ESSymbol) && maybeTypeOfKind(candidateType, TypeFlags.UniqueESSymbol) ||
|
||||
@@ -31419,7 +31413,7 @@ namespace ts {
|
||||
}
|
||||
// If the contextual type is a literal of a particular primitive type, we consider this a
|
||||
// literal context for all literals of that primitive type.
|
||||
return !!(contextualType.flags & (TypeFlags.StringLikeLiteral | TypeFlags.Index | TypeFlags.StringMapping) && maybeTypeOfKind(candidateType, TypeFlags.StringLikeLiteral) ||
|
||||
return !!(contextualType.flags & (TypeFlags.StringLiteral | TypeFlags.Index | TypeFlags.TemplateLiteral | TypeFlags.StringMapping) && maybeTypeOfKind(candidateType, TypeFlags.StringLiteral) ||
|
||||
contextualType.flags & TypeFlags.NumberLiteral && maybeTypeOfKind(candidateType, TypeFlags.NumberLiteral) ||
|
||||
contextualType.flags & TypeFlags.BigIntLiteral && maybeTypeOfKind(candidateType, TypeFlags.BigIntLiteral) ||
|
||||
contextualType.flags & TypeFlags.BooleanLiteral && maybeTypeOfKind(candidateType, TypeFlags.BooleanLiteral) ||
|
||||
@@ -38963,8 +38957,7 @@ namespace ts {
|
||||
|
||||
function isLiteralConstDeclaration(node: VariableDeclaration | PropertyDeclaration | PropertySignature | ParameterDeclaration): boolean {
|
||||
if (isDeclarationReadonly(node) || isVariableDeclaration(node) && isVarConst(node)) {
|
||||
const type = getTypeOfSymbol(getSymbolOfNode(node));
|
||||
return !!(type.flags & TypeFlags.Literal) && isFreshLiteralType(type);
|
||||
return isFreshLiteralType(getTypeOfSymbol(getSymbolOfNode(node)));
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
@@ -4972,10 +4972,6 @@ namespace ts {
|
||||
Unit = Literal | UniqueESSymbol | Nullable,
|
||||
StringOrNumberLiteral = StringLiteral | NumberLiteral,
|
||||
/* @internal */
|
||||
StringLikeLiteral = StringLiteral | TemplateLiteral,
|
||||
/* @internal */
|
||||
FreshableLiteral = Literal | TemplateLiteral,
|
||||
/* @internal */
|
||||
StringOrNumberLiteralOrUnique = StringLiteral | NumberLiteral | UniqueESSymbol,
|
||||
/* @internal */
|
||||
DefinitelyFalsy = StringLiteral | NumberLiteral | BigIntLiteral | BooleanLiteral | Void | Undefined | Null,
|
||||
@@ -5069,9 +5065,7 @@ namespace ts {
|
||||
}
|
||||
|
||||
/* @internal */
|
||||
export type FreshableLiteralType = LiteralType | TemplateLiteralType;
|
||||
/* @internal */
|
||||
export type FreshableType = FreshableLiteralType | FreshableIntrinsicType;
|
||||
export type FreshableType = LiteralType | FreshableIntrinsicType;
|
||||
|
||||
// String literal types (TypeFlags.StringLiteral)
|
||||
// Numeric literal types (TypeFlags.NumberLiteral)
|
||||
@@ -5475,8 +5469,6 @@ namespace ts {
|
||||
export interface TemplateLiteralType extends InstantiableType {
|
||||
texts: readonly string[]; // Always one element longer than types
|
||||
types: readonly Type[]; // Always at least one element
|
||||
freshType: TemplateLiteralType; // Fresh version of type
|
||||
regularType: TemplateLiteralType; // Regular version of type
|
||||
}
|
||||
|
||||
export interface StringMappingType extends InstantiableType {
|
||||
|
||||
Reference in new issue
Block a user