Skip to content

Commit 20eafb5

Browse files
weswighamweswigham
authored
Introduce boolean literal freshness (microsoft#27042)
1 parent 4eb59a2 commit 20eafb5

15 files changed

+165
-58
lines changed

‎src/compiler/checker.ts

Lines changed: 49 additions & 31 deletions
Original file line numberDiff line numberDiff line change
@@ -296,8 +296,8 @@ namespace ts {
296296
createPromiseType,
297297
createArrayType,
298298
getBooleanType: () => booleanType,
299-
getFalseType: () => falseType,
300-
getTrueType: () => trueType,
299+
getFalseType: (fresh?) => fresh ? falseType : regularFalseType,
300+
getTrueType: (fresh?) => fresh ? trueType : regularTrueType,
301301
getVoidType: () => voidType,
302302
getUndefinedType: () => undefinedType,
303303
getNullType: () => nullType,
@@ -405,9 +405,22 @@ namespace ts {
405405
const nullWideningType = strictNullChecks ? nullType : createIntrinsicType(TypeFlags.Null | TypeFlags.ContainsWideningType, "null");
406406
const stringType = createIntrinsicType(TypeFlags.String, "string");
407407
const numberType = createIntrinsicType(TypeFlags.Number, "number");
408-
const falseType = createIntrinsicType(TypeFlags.BooleanLiteral, "false");
409-
const trueType = createIntrinsicType(TypeFlags.BooleanLiteral, "true");
410-
const booleanType = createBooleanType([falseType, trueType]);
408+
const falseType = createIntrinsicType(TypeFlags.BooleanLiteral, "false") as FreshableIntrinsicType;
409+
const regularFalseType = createIntrinsicType(TypeFlags.BooleanLiteral, "false") as FreshableIntrinsicType;
410+
const trueType = createIntrinsicType(TypeFlags.BooleanLiteral, "true") as FreshableIntrinsicType;
411+
const regularTrueType = createIntrinsicType(TypeFlags.BooleanLiteral, "true") as FreshableIntrinsicType;
412+
falseType.flags |= TypeFlags.FreshLiteral;
413+
trueType.flags |= TypeFlags.FreshLiteral;
414+
trueType.regularType = regularTrueType;
415+
regularTrueType.freshType = trueType;
416+
falseType.regularType = regularFalseType;
417+
regularFalseType.freshType = falseType;
418+
const booleanType = createBooleanType([regularFalseType, regularTrueType]);
419+
// Also mark all combinations of fresh/regular booleans as "Boolean" so they print as `boolean` instead of `true | false`
420+
// (The union is cached, so simply doing the marking here is sufficient)
421+
createBooleanType([regularFalseType, trueType]);
422+
createBooleanType([falseType, regularTrueType]);
423+
createBooleanType([falseType, trueType]);
411424
const esSymbolType = createIntrinsicType(TypeFlags.ESSymbol, "symbol");
412425
const voidType = createIntrinsicType(TypeFlags.Void, "void");
413426
const neverType = createIntrinsicType(TypeFlags.Never, "never");
@@ -4173,7 +4186,7 @@ namespace ts {
41734186
const baseType = t.flags & TypeFlags.BooleanLiteral ? booleanType : getBaseTypeOfEnumLiteralType(<LiteralType>t);
41744187
if (baseType.flags & TypeFlags.Union) {
41754188
const count = (<UnionType>baseType).types.length;
4176-
if (i + count <= types.length && types[i + count - 1] === (<UnionType>baseType).types[count - 1]) {
4189+
if (i + count <= types.length && getRegularTypeOfLiteralType(types[i + count - 1]) === getRegularTypeOfLiteralType((<UnionType>baseType).types[count - 1])) {
41774190
result.push(baseType);
41784191
i += count - 1;
41794192
continue;
@@ -6160,7 +6173,7 @@ namespace ts {
61606173
if (type.flags & TypeFlags.UniqueESSymbol) {
61616174
return `__@${type.symbol.escapedName}@${getSymbolId(type.symbol)}` as __String;
61626175
}
6163-
if (type.flags & TypeFlags.StringOrNumberLiteral) {
6176+
if (type.flags & (TypeFlags.StringLiteral | TypeFlags.NumberLiteral)) {
61646177
return escapeLeadingUnderscores("" + (<LiteralType>type).value);
61656178
}
61666179
return Debug.fail();
@@ -8813,7 +8826,7 @@ namespace ts {
88138826
t.flags & TypeFlags.StringLiteral && includes & TypeFlags.String ||
88148827
t.flags & TypeFlags.NumberLiteral && includes & TypeFlags.Number ||
88158828
t.flags & TypeFlags.UniqueESSymbol && includes & TypeFlags.ESSymbol ||
8816-
t.flags & TypeFlags.StringOrNumberLiteral && t.flags & TypeFlags.FreshLiteral && containsType(types, (<LiteralType>t).regularType);
8829+
t.flags & TypeFlags.Literal && t.flags & TypeFlags.FreshLiteral && containsType(types, (<LiteralType>t).regularType);
88178830
if (remove) {
88188831
orderedRemoveItemAt(types, i);
88198832
}
@@ -9813,8 +9826,8 @@ namespace ts {
98139826
}
98149827

98159828
function getFreshTypeOfLiteralType(type: Type): Type {
9816-
if (type.flags & TypeFlags.StringOrNumberLiteral && !(type.flags & TypeFlags.FreshLiteral)) {
9817-
if (!(<LiteralType>type).freshType) {
9829+
if (type.flags & TypeFlags.Literal && !(type.flags & TypeFlags.FreshLiteral)) {
9830+
if (!(<LiteralType>type).freshType) { // NOTE: Safe because all freshable intrinsics always have fresh types already
98189831
const freshType = createLiteralType(type.flags | TypeFlags.FreshLiteral, (<LiteralType>type).value, (<LiteralType>type).symbol);
98199832
freshType.regularType = <LiteralType>type;
98209833
(<LiteralType>type).freshType = freshType;
@@ -9825,7 +9838,7 @@ namespace ts {
98259838
}
98269839

98279840
function getRegularTypeOfLiteralType(type: Type): Type {
9828-
return type.flags & TypeFlags.StringOrNumberLiteral && type.flags & TypeFlags.FreshLiteral ? (<LiteralType>type).regularType :
9841+
return type.flags & TypeFlags.Literal && type.flags & TypeFlags.FreshLiteral ? (<LiteralType>type).regularType :
98299842
type.flags & TypeFlags.Union ? getUnionType(sameMap((<UnionType>type).types, getRegularTypeOfLiteralType)) :
98309843
type;
98319844
}
@@ -11038,11 +11051,11 @@ namespace ts {
1103811051
}
1103911052

1104011053
function isTypeRelatedTo(source: Type, target: Type, relation: Map<RelationComparisonResult>) {
11041-
if (source.flags & TypeFlags.StringOrNumberLiteral && source.flags & TypeFlags.FreshLiteral) {
11042-
source = (<LiteralType>source).regularType;
11054+
if (source.flags & TypeFlags.Literal && source.flags & TypeFlags.FreshLiteral) {
11055+
source = (<FreshableType>source).regularType;
1104311056
}
11044-
if (target.flags & TypeFlags.StringOrNumberLiteral && target.flags & TypeFlags.FreshLiteral) {
11045-
target = (<LiteralType>target).regularType;
11057+
if (target.flags & TypeFlags.Literal && target.flags & TypeFlags.FreshLiteral) {
11058+
target = (<FreshableType>target).regularType;
1104611059
}
1104711060
if (source === target ||
1104811061
relation === comparableRelation && !(target.flags & TypeFlags.Never) && isSimpleTypeRelatedTo(target, source, relation) ||
@@ -11197,11 +11210,11 @@ namespace ts {
1119711210
* * Ternary.False if they are not related.
1119811211
*/
1119911212
function isRelatedTo(source: Type, target: Type, reportErrors = false, headMessage?: DiagnosticMessage): Ternary {
11200-
if (source.flags & TypeFlags.StringOrNumberLiteral && source.flags & TypeFlags.FreshLiteral) {
11201-
source = (<LiteralType>source).regularType;
11213+
if (source.flags & TypeFlags.Literal && source.flags & TypeFlags.FreshLiteral) {
11214+
source = (<FreshableType>source).regularType;
1120211215
}
11203-
if (target.flags & TypeFlags.StringOrNumberLiteral && target.flags & TypeFlags.FreshLiteral) {
11204-
target = (<LiteralType>target).regularType;
11216+
if (target.flags & TypeFlags.Literal && target.flags & TypeFlags.FreshLiteral) {
11217+
target = (<FreshableType>target).regularType;
1120511218
}
1120611219
if (source.flags & TypeFlags.Substitution) {
1120711220
source = relation === definitelyAssignableRelation ? (<SubstitutionType>source).typeVariable : (<SubstitutionType>source).substitute;
@@ -12769,7 +12782,7 @@ namespace ts {
1276912782
return type.flags & TypeFlags.EnumLiteral && type.flags & TypeFlags.FreshLiteral ? getBaseTypeOfEnumLiteralType(<LiteralType>type) :
1277012783
type.flags & TypeFlags.StringLiteral && type.flags & TypeFlags.FreshLiteral ? stringType :
1277112784
type.flags & TypeFlags.NumberLiteral && type.flags & TypeFlags.FreshLiteral ? numberType :
12772-
type.flags & TypeFlags.BooleanLiteral ? booleanType :
12785+
type.flags & TypeFlags.BooleanLiteral && type.flags & TypeFlags.FreshLiteral ? booleanType :
1277312786
type.flags & TypeFlags.Union ? getUnionType(sameMap((<UnionType>type).types, getWidenedLiteralType)) :
1277412787
type;
1277512788
}
@@ -12823,7 +12836,7 @@ namespace ts {
1282312836
return type.flags & TypeFlags.Union ? getFalsyFlagsOfTypes((<UnionType>type).types) :
1282412837
type.flags & TypeFlags.StringLiteral ? (<LiteralType>type).value === "" ? TypeFlags.StringLiteral : 0 :
1282512838
type.flags & TypeFlags.NumberLiteral ? (<LiteralType>type).value === 0 ? TypeFlags.NumberLiteral : 0 :
12826-
type.flags & TypeFlags.BooleanLiteral ? type === falseType ? TypeFlags.BooleanLiteral : 0 :
12839+
type.flags & TypeFlags.BooleanLiteral ? (type === falseType || type === regularFalseType) ? TypeFlags.BooleanLiteral : 0 :
1282712840
type.flags & TypeFlags.PossiblyFalsy;
1282812841
}
1282912842

@@ -12840,7 +12853,8 @@ namespace ts {
1284012853
function getDefinitelyFalsyPartOfType(type: Type): Type {
1284112854
return type.flags & TypeFlags.String ? emptyStringType :
1284212855
type.flags & TypeFlags.Number ? zeroType :
12843-
type.flags & TypeFlags.Boolean || type === falseType ? falseType :
12856+
type.flags & TypeFlags.Boolean || type === regularFalseType ? regularFalseType :
12857+
type === falseType ? falseType :
1284412858
type.flags & (TypeFlags.Void | TypeFlags.Undefined | TypeFlags.Null) ||
1284512859
type.flags & TypeFlags.StringLiteral && (<LiteralType>type).value === "" ||
1284612860
type.flags & TypeFlags.NumberLiteral && (<LiteralType>type).value === 0 ? type :
@@ -14095,7 +14109,10 @@ namespace ts {
1409514109
if (assignedType.flags & TypeFlags.Never) {
1409614110
return assignedType;
1409714111
}
14098-
const reducedType = filterType(declaredType, t => typeMaybeAssignableTo(assignedType, t));
14112+
let reducedType = filterType(declaredType, t => typeMaybeAssignableTo(assignedType, t));
14113+
if (assignedType.flags & (TypeFlags.FreshLiteral | TypeFlags.Literal)) {
14114+
reducedType = mapType(reducedType, getFreshTypeOfLiteralType); // Ensure that if the assignment is a fresh type, that we narrow to fresh types
14115+
}
1409914116
// Our crude heuristic produces an invalid result in some cases: see GH#26130.
1410014117
// For now, when that happens, we give up and don't narrow at all. (This also
1410114118
// means we'll never narrow for erroneous assignments where the assigned type
@@ -14148,8 +14165,8 @@ namespace ts {
1414814165
}
1414914166
if (flags & TypeFlags.BooleanLike) {
1415014167
return strictNullChecks ?
14151-
type === falseType ? TypeFacts.FalseStrictFacts : TypeFacts.TrueStrictFacts :
14152-
type === falseType ? TypeFacts.FalseFacts : TypeFacts.TrueFacts;
14168+
(type === falseType || type === regularFalseType) ? TypeFacts.FalseStrictFacts : TypeFacts.TrueStrictFacts :
14169+
(type === falseType || type === regularFalseType) ? TypeFacts.FalseFacts : TypeFacts.TrueFacts;
1415314170
}
1415414171
if (flags & TypeFlags.Object) {
1415514172
return isFunctionObjectType(<ObjectType>type) ?
@@ -28381,19 +28398,20 @@ namespace ts {
2838128398
function isLiteralConstDeclaration(node: VariableDeclaration | PropertyDeclaration | PropertySignature | ParameterDeclaration): boolean {
2838228399
if (isDeclarationReadonly(node) || isVariableDeclaration(node) && isVarConst(node)) {
2838328400
const type = getTypeOfSymbol(getSymbolOfNode(node));
28384-
return !!(type.flags & TypeFlags.StringOrNumberLiteral && type.flags & TypeFlags.FreshLiteral);
28401+
return !!(type.flags & TypeFlags.Literal && type.flags & TypeFlags.FreshLiteral);
2838528402
}
2838628403
return false;
2838728404
}
2838828405

28389-
function literalTypeToNode(type: LiteralType, enclosing: Node): Expression {
28390-
const enumResult = type.flags & TypeFlags.EnumLiteral && nodeBuilder.symbolToExpression(type.symbol, SymbolFlags.Value, enclosing);
28391-
return enumResult || createLiteral(type.value);
28406+
function literalTypeToNode(type: FreshableType, enclosing: Node): Expression {
28407+
const enumResult = type.flags & TypeFlags.EnumLiteral ? nodeBuilder.symbolToExpression(type.symbol, SymbolFlags.Value, enclosing)
28408+
: type === trueType ? createTrue() : type === falseType && createFalse();
28409+
return enumResult || createLiteral((type as LiteralType).value);
2839228410
}
2839328411

2839428412
function createLiteralConstValue(node: VariableDeclaration | PropertyDeclaration | PropertySignature | ParameterDeclaration) {
2839528413
const type = getTypeOfSymbol(getSymbolOfNode(node));
28396-
return literalTypeToNode(<LiteralType>type, node);
28414+
return literalTypeToNode(<FreshableType>type, node);
2839728415
}
2839828416

2839928417
function createResolver(): EmitResolver {
@@ -29765,7 +29783,7 @@ namespace ts {
2976529783

2976629784
function checkAmbientInitializer(node: VariableDeclaration | PropertyDeclaration | PropertySignature) {
2976729785
if (node.initializer) {
29768-
const isInvalidInitializer = !(isStringOrNumberLiteralExpression(node.initializer) || isSimpleLiteralEnumReference(node.initializer));
29786+
const isInvalidInitializer = !(isStringOrNumberLiteralExpression(node.initializer) || isSimpleLiteralEnumReference(node.initializer) || node.initializer.kind === SyntaxKind.TrueKeyword || node.initializer.kind === SyntaxKind.FalseKeyword);
2976929787
const isConstOrReadonly = isDeclarationReadonly(node) || isVariableDeclaration(node) && isVarConst(node);
2977029788
if (isConstOrReadonly && !node.type) {
2977129789
if (isInvalidInitializer) {

‎src/compiler/types.ts

Lines changed: 12 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -3034,8 +3034,8 @@ namespace ts {
30343034
/* @internal */ getStringType(): Type;
30353035
/* @internal */ getNumberType(): Type;
30363036
/* @internal */ getBooleanType(): Type;
3037-
/* @internal */ getFalseType(): Type;
3038-
/* @internal */ getTrueType(): Type;
3037+
/* @internal */ getFalseType(fresh?: boolean): Type;
3038+
/* @internal */ getTrueType(fresh?: boolean): Type;
30393039
/* @internal */ getVoidType(): Type;
30403040
/* @internal */ getUndefinedType(): Type;
30413041
/* @internal */ getNullType(): Type;
@@ -3731,7 +3731,7 @@ namespace ts {
37313731
Unit = Literal | UniqueESSymbol | Nullable,
37323732
StringOrNumberLiteral = StringLiteral | NumberLiteral,
37333733
/* @internal */
3734-
StringOrNumberLiteralOrUnique = StringOrNumberLiteral | UniqueESSymbol,
3734+
StringOrNumberLiteralOrUnique = StringLiteral | NumberLiteral | UniqueESSymbol,
37353735
/* @internal */
37363736
DefinitelyFalsy = StringLiteral | NumberLiteral | BooleanLiteral | Void | Undefined | Null,
37373737
PossiblyFalsy = DefinitelyFalsy | String | Number | Boolean,
@@ -3802,6 +3802,15 @@ namespace ts {
38023802
intrinsicName: string; // Name of intrinsic type
38033803
}
38043804

3805+
/* @internal */
3806+
export interface FreshableIntrinsicType extends IntrinsicType {
3807+
freshType: IntrinsicType; // Fresh version of type
3808+
regularType: IntrinsicType; // Regular version of type
3809+
}
3810+
3811+
/* @internal */
3812+
export type FreshableType = LiteralType | FreshableIntrinsicType;
3813+
38053814
// String literal types (TypeFlags.StringLiteral)
38063815
// Numeric literal types (TypeFlags.NumberLiteral)
38073816
export interface LiteralType extends Type {

‎src/services/codefixes/fixStrictClassInitialization.ts

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -110,7 +110,7 @@ namespace ts.codefix {
110110

111111
function getDefaultValueFromType (checker: TypeChecker, type: Type): Expression | undefined {
112112
if (type.flags & TypeFlags.BooleanLiteral) {
113-
return type === checker.getFalseType() ? createFalse() : createTrue();
113+
return (type === checker.getFalseType() || type === checker.getFalseType(/*fresh*/ true)) ? createFalse() : createTrue();
114114
}
115115
else if (type.isLiteral()) {
116116
return createLiteral(type.value);

‎tests/baselines/reference/ambientConstLiterals.js

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -63,7 +63,7 @@ declare const c3 = "abc";
6363
declare const c4 = 123;
6464
declare const c5 = 123;
6565
declare const c6 = -123;
66-
declare const c7: boolean;
66+
declare const c7 = true;
6767
declare const c8 = E.A;
6868
declare const c8b = E["non identifier"];
6969
declare const c9: {

‎tests/baselines/reference/booleanLiteralTypes1.types

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -82,13 +82,13 @@ function f4(t: true, f: false) {
8282
>false : false
8383

8484
var x1 = t && f;
85-
>x1 : boolean
85+
>x1 : false
8686
>t && f : false
8787
>t : true
8888
>f : false
8989

9090
var x2 = f && t;
91-
>x2 : boolean
91+
>x2 : false
9292
>f && t : false
9393
>f : false
9494
>t : true
@@ -100,7 +100,7 @@ function f4(t: true, f: false) {
100100
>f : false
101101

102102
var x4 = f || t;
103-
>x4 : boolean
103+
>x4 : true
104104
>f || t : true
105105
>f : false
106106
>t : true

‎tests/baselines/reference/booleanLiteralTypes2.types

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -82,25 +82,25 @@ function f4(t: true, f: false) {
8282
>false : false
8383

8484
var x1 = t && f;
85-
>x1 : boolean
85+
>x1 : false
8686
>t && f : false
8787
>t : true
8888
>f : false
8989

9090
var x2 = f && t;
91-
>x2 : boolean
91+
>x2 : false
9292
>f && t : false
9393
>f : false
9494
>t : true
9595

9696
var x3 = t || f;
97-
>x3 : boolean
97+
>x3 : true
9898
>t || f : true
9999
>t : true
100100
>f : false
101101

102102
var x4 = f || t;
103-
>x4 : boolean
103+
>x4 : true
104104
>f || t : true
105105
>f : false
106106
>t : true

‎tests/baselines/reference/constDeclarations.js

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -24,6 +24,6 @@ for (const c5 = 0, c6 = 0; c5 < c6;) {
2424

2525

2626
//// [constDeclarations.d.ts]
27-
declare const c1: boolean;
27+
declare const c1 = false;
2828
declare const c2: number;
2929
declare const c3 = 0, c4: string, c5: any;

‎tests/baselines/reference/constDeclarations2.js

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -19,7 +19,7 @@ var M;
1919

2020
//// [constDeclarations2.d.ts]
2121
declare module M {
22-
const c1: boolean;
22+
const c1 = false;
2323
const c2: number;
2424
const c3 = 0, c4: string, c5: any;
2525
}

0 commit comments

Comments
 (0)