microsoft/TypeScript
1
0
Fork 0
mirror of https://github.com/microsoft/TypeScript.git synced 2026-05-18 17:27:54 -05:00
Code Issues Packages Projects Releases 212 Wiki Activity

More repetitive but less complex widening logic for literals/symbols

Browse Source
This commit is contained in:
Ron Buckton
2017-10-26 14:50:41 -07:00
parent 51929acb89
commit 3febc802cf
4 changed files with 16 additions and 53 deletions
Download Patch File Download Diff File Expand all files Collapse all files

62
src/compiler/checker.ts
View File

@@ -10647,61 +10647,31 @@ namespace ts {
type;
}
function getWidenedLiteralLikeMapper(wideningFlags: TypeFlags) {
return !(wideningFlags & TypeFlags.UniqueESSymbol) ? getWidenedLiteralType :
!(wideningFlags & TypeFlags.WidenableLiteral) ? getWidenedUniqueESSymbolType :
getWidenedLiteralLikeType;
}
/**
* Widens string literal, number literal, boolean literal, enum literal, and unique symbol
* types, as well as unions of the same.
*
* We don't always want to widen literals in all of the same places we widen unique symbol
* types, and vice versa. However, there are some cases where we do widen both sets of
* types at the same time.
*
* In general, this function should not be called directly. Instead it should be called
* through either `getWidenedLiteralType` (which does not widen unique symbol types),
* `getWidenedUniqueESSymbolType` (which only widenes unique symbol types), or
* `getWidenedLiteralLikeType` (which widens both).
*/
function getWidenedLiteralLikeTypeWorker(type: Type, wideningFlags: TypeFlags): Type {
return type.flags & wideningFlags & TypeFlags.EnumLiteral ? getBaseTypeOfEnumLiteralType(<LiteralType>type) :
type.flags & wideningFlags & TypeFlags.StringLiteral && type.flags & TypeFlags.FreshLiteral ? stringType :
type.flags & wideningFlags & TypeFlags.NumberLiteral && type.flags & TypeFlags.FreshLiteral ? numberType :
type.flags & wideningFlags & TypeFlags.BooleanLiteral ? booleanType :
type.flags & wideningFlags & TypeFlags.UniqueESSymbol ? esSymbolType :
type.flags & TypeFlags.Union ? getUnionType(sameMap((<UnionType>type).types, getWidenedLiteralLikeMapper(wideningFlags))) :
function getWidenedLiteralLikeType(type: Type): Type {
return type.flags & TypeFlags.EnumLiteral ? getBaseTypeOfEnumLiteralType(<LiteralType>type) :
type.flags & TypeFlags.StringLiteral && type.flags & TypeFlags.FreshLiteral ? stringType :
type.flags & TypeFlags.NumberLiteral && type.flags & TypeFlags.FreshLiteral ? numberType :
type.flags & TypeFlags.BooleanLiteral ? booleanType :
type.flags & TypeFlags.UniqueESSymbol ? esSymbolType :
type.flags & TypeFlags.Union ? getUnionType(sameMap((<UnionType>type).types, getWidenedLiteralLikeType)) :
type;
}
/**
* Widens string literal, number literal, boolean literal, enum literal, and unique symbol
* types, as well as unions of the same.
*/
function getWidenedLiteralLikeType(type: Type): Type {
return getWidenedLiteralLikeTypeWorker(type, TypeFlags.WidenableLiteralLike);
}
/**
* Widens string literal, number literal, boolean literal, and enum literal types, as well
* as unions of the same.
*/
function getWidenedLiteralType(type: Type): Type {
return getWidenedLiteralLikeTypeWorker(type, TypeFlags.WidenableLiteral);
return type.flags & TypeFlags.EnumLiteral ? getBaseTypeOfEnumLiteralType(<LiteralType>type) :
type.flags & TypeFlags.StringLiteral && type.flags & TypeFlags.FreshLiteral ? stringType :
type.flags & TypeFlags.NumberLiteral && type.flags & TypeFlags.FreshLiteral ? numberType :
type.flags & TypeFlags.BooleanLiteral ? booleanType :
type.flags & TypeFlags.Union ? getUnionType(sameMap((<UnionType>type).types, getWidenedLiteralType)) :
type;
}
/**
* Widens unique symbol types and unions of unique symbol types.
*/
function getWidenedUniqueESSymbolType(type: Type): Type {
return getWidenedLiteralLikeTypeWorker(type, TypeFlags.UniqueESSymbol);
return type.flags & TypeFlags.UniqueESSymbol ? esSymbolType :
type.flags & TypeFlags.Union ? getUnionType(sameMap((<UnionType>type).types, getWidenedUniqueESSymbolType)) :
type;
}
/**
* Widens a literal-like type when the contextual type is not literal-like.
*/
function getWidenedLiteralLikeTypeForContextualType(type: Type, contextualType: Type) {
const widenLiterals = !isLiteralContextualType(contextualType);
const widenSymbols = !isUniqueESSymbolContextualType(contextualType);

3
src/compiler/types.ts
View File

@@ -3306,9 +3306,6 @@ namespace ts {
RequiresWidening = ContainsWideningType | ContainsObjectLiteral,
/* @internal */
PropagatingFlags = ContainsWideningType | ContainsObjectLiteral | ContainsAnyFunctionType,
WidenableLiteral = Literal | EnumLiteral,
WidenableLiteralLike = WidenableLiteral | UniqueESSymbol,
}
export type DestructuringPattern = BindingPattern | ObjectLiteralExpression | ArrayLiteralExpression;