Skip to content

Commit 28e9ec4

Browse files
committed
Address review comments
1 parent a931313 commit 28e9ec4

File tree

39 files changed

+961
-838
lines changed

39 files changed

+961
-838
lines changed

src/compiler/binder.ts

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -3697,13 +3697,13 @@ namespace ts {
36973697
break;
36983698

36993699
case SyntaxKind.NumericLiteral:
3700-
const flags = (<NumericLiteral>node).numericLiteralFlags;
3701-
if (flags & TokenFlags.BinaryOrOctalSpecifier) {
3700+
if ((<NumericLiteral>node).numericLiteralFlags & TokenFlags.BinaryOrOctalSpecifier) {
37023701
transformFlags |= TransformFlags.AssertES2015;
37033702
}
3704-
if (flags & TokenFlags.BigInt) {
3705-
transformFlags |= TransformFlags.AssertESNext;
3706-
}
3703+
break;
3704+
3705+
case SyntaxKind.BigIntLiteral:
3706+
transformFlags |= TransformFlags.AssertESNext;
37073707
break;
37083708

37093709
case SyntaxKind.ForOfStatement:

src/compiler/checker.ts

Lines changed: 41 additions & 33 deletions
Original file line numberDiff line numberDiff line change
@@ -9268,27 +9268,20 @@ namespace ts {
92689268
type.resolvedIndexType || (type.resolvedIndexType = createIndexType(type, /*stringsOnly*/ false));
92699269
}
92709270

9271-
function getNumericLiteralValue(node: NumericLiteral): number | PseudoBigInt {
9272-
if (node.numericLiteralFlags & TokenFlags.BigInt) {
9273-
if (!compilerOptions.experimentalBigInt) {
9274-
error(node, Diagnostics.Experimental_support_for_BigInt_is_a_feature_that_is_subject_to_change_in_a_future_release_Set_the_experimentalBigInt_option_to_remove_this_warning);
9275-
}
9276-
return { negative: false, base10Value: parsePseudoBigInt(node.text) };
9277-
}
9278-
return +node.text;
9279-
}
9280-
9281-
function getNumericLiteralType(node: NumericLiteral): LiteralType {
9282-
return getLiteralType(getNumericLiteralValue(node));
9271+
function getBigIntLiteralType(node: BigIntLiteral): LiteralType {
9272+
return getLiteralType({
9273+
negative: false,
9274+
base10Value: parsePseudoBigInt(node.text)
9275+
});
92839276
}
92849277

92859278
function getLiteralTypeFromPropertyName(prop: Symbol, include: TypeFlags) {
92869279
if (!(getDeclarationModifierFlagsFromSymbol(prop) & ModifierFlags.NonPublicAccessibilityModifier)) {
92879280
let type = getLateBoundSymbol(prop).nameType;
92889281
if (!type && !isKnownSymbol(prop)) {
92899282
const name = prop.valueDeclaration && getNameOfDeclaration(prop.valueDeclaration);
9290-
type = name && isNumericLiteral(name) ? getNumericLiteralType(name) :
9291-
name && name.kind === SyntaxKind.ComputedPropertyName && isNumericLiteral(name.expression) ? getNumericLiteralType(name.expression) :
9283+
type = name && isNumericLiteral(name) ? getLiteralType(+name.text) :
9284+
name && name.kind === SyntaxKind.ComputedPropertyName && isNumericLiteral(name.expression) ? getLiteralType(+name.expression.text) :
92929285
getLiteralType(symbolName(prop));
92939286
}
92949287
if (type && type.flags & include) {
@@ -17077,6 +17070,7 @@ namespace ts {
1707717070
switch (node.kind) {
1707817071
case SyntaxKind.StringLiteral:
1707917072
case SyntaxKind.NumericLiteral:
17073+
case SyntaxKind.BigIntLiteral:
1708017074
case SyntaxKind.NoSubstitutionTemplateLiteral:
1708117075
case SyntaxKind.TrueKeyword:
1708217076
case SyntaxKind.FalseKeyword:
@@ -21503,22 +21497,22 @@ namespace ts {
2150321497
if (operandType === silentNeverType) {
2150421498
return silentNeverType;
2150521499
}
21506-
if (node.operand.kind === SyntaxKind.NumericLiteral) {
21507-
if (node.operator === SyntaxKind.MinusToken) {
21508-
const value = getNumericLiteralValue(node.operand as NumericLiteral);
21509-
return getFreshTypeOfLiteralType(getLiteralType(
21510-
// Keep number as number, bigint as bigint
21511-
typeof value === "number"
21512-
? -value
21513-
: { negative: !value.negative, base10Value: value.base10Value }
21514-
));
21515-
}
21516-
else if (node.operator === SyntaxKind.PlusToken) {
21517-
if (isTypeAssignableToKind(operandType, TypeFlags.BigIntLike)) {
21518-
error(node.operand, Diagnostics.Operator_0_cannot_be_applied_to_type_1, tokenToString(node.operator), typeToString(operandType));
21500+
switch (node.operand.kind) {
21501+
case SyntaxKind.NumericLiteral:
21502+
switch (node.operator) {
21503+
case SyntaxKind.MinusToken:
21504+
return getFreshTypeOfLiteralType(getLiteralType(-(node.operand as NumericLiteral).text));
21505+
case SyntaxKind.PlusToken:
21506+
return getFreshTypeOfLiteralType(getLiteralType(+(node.operand as NumericLiteral).text));
21507+
}
21508+
break;
21509+
case SyntaxKind.BigIntLiteral:
21510+
if (node.operator === SyntaxKind.MinusToken) {
21511+
return getFreshTypeOfLiteralType(getLiteralType({
21512+
negative: true,
21513+
base10Value: parsePseudoBigInt((node.operand as BigIntLiteral).text)
21514+
}));
2151921515
}
21520-
return getFreshTypeOfLiteralType(getNumericLiteralType(node.operand as NumericLiteral));
21521-
}
2152221516
}
2152321517
switch (node.operator) {
2152421518
case SyntaxKind.PlusToken:
@@ -21860,6 +21854,7 @@ namespace ts {
2186021854
case SyntaxKind.TemplateExpression:
2186121855
case SyntaxKind.NoSubstitutionTemplateLiteral:
2186221856
case SyntaxKind.NumericLiteral:
21857+
case SyntaxKind.BigIntLiteral:
2186321858
case SyntaxKind.TrueKeyword:
2186421859
case SyntaxKind.FalseKeyword:
2186521860
case SyntaxKind.NullKeyword:
@@ -22002,7 +21997,6 @@ namespace ts {
2200221997
}
2200321998
return resultType;
2200421999
}
22005-
2200622000
case SyntaxKind.PlusToken:
2200722001
case SyntaxKind.PlusEqualsToken:
2200822002
if (leftType === silentNeverType || rightType === silentNeverType) {
@@ -22558,7 +22552,10 @@ namespace ts {
2255822552
return getFreshTypeOfLiteralType(getLiteralType((node as StringLiteralLike).text));
2255922553
case SyntaxKind.NumericLiteral:
2256022554
checkGrammarNumericLiteral(node as NumericLiteral);
22561-
return getFreshTypeOfLiteralType(getNumericLiteralType(node as NumericLiteral));
22555+
return getFreshTypeOfLiteralType(getLiteralType(+(node as NumericLiteral).text));
22556+
case SyntaxKind.BigIntLiteral:
22557+
checkGrammarBigIntLiteral(node as BigIntLiteral);
22558+
return getFreshTypeOfLiteralType(getBigIntLiteralType(node as BigIntLiteral));
2256222559
case SyntaxKind.TrueKeyword:
2256322560
return trueType;
2256422561
case SyntaxKind.FalseKeyword:
@@ -26595,8 +26592,7 @@ namespace ts {
2659526592
return (<StringLiteral>expr).text;
2659626593
case SyntaxKind.NumericLiteral:
2659726594
checkGrammarNumericLiteral(<NumericLiteral>expr);
26598-
const literalValue = getNumericLiteralValue(<NumericLiteral>expr);
26599-
return typeof literalValue === "number" ? literalValue : undefined; // don't evaluate bigint
26595+
return +(<NumericLiteral>expr).text;
2660026596
case SyntaxKind.ParenthesizedExpression:
2660126597
return evaluate((<ParenthesizedExpression>expr).expression);
2660226598
case SyntaxKind.Identifier:
@@ -30462,6 +30458,18 @@ namespace ts {
3046230458
return false;
3046330459
}
3046430460

30461+
function checkGrammarBigIntLiteral(node: BigIntLiteral): boolean {
30462+
if (languageVersion < ScriptTarget.ESNext) {
30463+
if (grammarErrorOnNode(node, Diagnostics.BigInt_literals_are_not_available_when_targetting_lower_than_ESNext)) {
30464+
return true;
30465+
}
30466+
}
30467+
if (!compilerOptions.experimentalBigInt) {
30468+
return grammarErrorOnNode(node, Diagnostics.Experimental_support_for_BigInt_is_a_feature_that_is_subject_to_change_in_a_future_release_Set_the_experimentalBigInt_option_to_remove_this_warning);
30469+
}
30470+
return false;
30471+
}
30472+
3046530473
function grammarErrorAfterFirstToken(node: Node, message: DiagnosticMessage, arg0?: any, arg1?: any, arg2?: any): boolean {
3046630474
const sourceFile = getSourceFileOfNode(node);
3046730475
if (!hasParseDiagnostics(sourceFile)) {

src/compiler/commandLineParser.ts

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -588,7 +588,7 @@ namespace ts {
588588
name: "experimentalBigInt",
589589
type: "boolean",
590590
category: Diagnostics.Experimental_Options,
591-
description: Diagnostics.Enables_experimental_support_for_ESNext_BigInt_expressions
591+
description: Diagnostics.Enables_experimental_support_for_ESNext_BigInt_literals
592592
},
593593

594594
// Advanced

src/compiler/diagnosticMessages.json

Lines changed: 5 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -2505,6 +2505,10 @@
25052505
"category": "Error",
25062506
"code": 2736
25072507
},
2508+
"BigInt literals are not available when targetting lower than ESNext.": {
2509+
"category": "Error",
2510+
"code": 2737
2511+
},
25082512

25092513
"Import declaration '{0}' is using private name '{1}'.": {
25102514
"category": "Error",
@@ -3913,7 +3917,7 @@
39133917
"category": "Error",
39143918
"code": 6370
39153919
},
3916-
"Enables experimental support for ESNext BigInt expressions.": {
3920+
"Enables experimental support for ESNext BigInt literals.": {
39173921
"category": "Message",
39183922
"code": 6371
39193923
},

src/compiler/emitter.ts

Lines changed: 4 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -905,7 +905,8 @@ namespace ts {
905905
switch (node.kind) {
906906
// Literals
907907
case SyntaxKind.NumericLiteral:
908-
return emitNumericLiteral(<NumericLiteral>node);
908+
case SyntaxKind.BigIntLiteral:
909+
return emitNumericOrBigIntLiteral(<NumericLiteral | BigIntLiteral>node);
909910

910911
case SyntaxKind.StringLiteral:
911912
case SyntaxKind.RegularExpressionLiteral:
@@ -1068,7 +1069,8 @@ namespace ts {
10681069
//
10691070

10701071
// SyntaxKind.NumericLiteral
1071-
function emitNumericLiteral(node: NumericLiteral) {
1072+
// SyntaxKind.BigIntLiteral
1073+
function emitNumericOrBigIntLiteral(node: NumericLiteral | BigIntLiteral) {
10721074
emitLiteral(node);
10731075
}
10741076

src/compiler/factory.ts

Lines changed: 8 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -76,9 +76,7 @@ namespace ts {
7676
return createNumericLiteral(value + "");
7777
}
7878
if (typeof value === "object" && "base10Value" in value) { // PseudoBigInt
79-
const literal = createNumericLiteral(pseudoBigIntToString(value) + "n");
80-
literal.numericLiteralFlags |= TokenFlags.BigInt;
81-
return literal;
79+
return createBigIntLiteral(pseudoBigIntToString(value) + "n");
8280
}
8381
if (typeof value === "boolean") {
8482
return value ? createTrue() : createFalse();
@@ -98,6 +96,12 @@ namespace ts {
9896
return node;
9997
}
10098

99+
export function createBigIntLiteral(value: string): BigIntLiteral {
100+
const node = <BigIntLiteral>createSynthesizedNode(SyntaxKind.BigIntLiteral);
101+
node.text = value;
102+
return node;
103+
}
104+
101105
export function createStringLiteral(text: string): StringLiteral {
102106
const node = <StringLiteral>createSynthesizedNode(SyntaxKind.StringLiteral);
103107
node.text = text;
@@ -3472,6 +3476,7 @@ namespace ts {
34723476
return cacheIdentifiers;
34733477
case SyntaxKind.ThisKeyword:
34743478
case SyntaxKind.NumericLiteral:
3479+
case SyntaxKind.BigIntLiteral:
34753480
case SyntaxKind.StringLiteral:
34763481
return false;
34773482
case SyntaxKind.ArrayLiteralExpression:

src/compiler/parser.ts

Lines changed: 10 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -2891,8 +2891,9 @@ namespace ts {
28912891
return finishNode(node);
28922892
}
28932893

2894-
function nextTokenIsNumericLiteral() {
2895-
return nextToken() === SyntaxKind.NumericLiteral;
2894+
function nextTokenIsNumericOrBigIntLiteral() {
2895+
nextToken();
2896+
return token() === SyntaxKind.NumericLiteral || token() === SyntaxKind.BigIntLiteral;
28962897
}
28972898

28982899
function parseNonArrayType(): TypeNode {
@@ -2922,11 +2923,12 @@ namespace ts {
29222923
case SyntaxKind.NoSubstitutionTemplateLiteral:
29232924
case SyntaxKind.StringLiteral:
29242925
case SyntaxKind.NumericLiteral:
2926+
case SyntaxKind.BigIntLiteral:
29252927
case SyntaxKind.TrueKeyword:
29262928
case SyntaxKind.FalseKeyword:
29272929
return parseLiteralTypeNode();
29282930
case SyntaxKind.MinusToken:
2929-
return lookAhead(nextTokenIsNumericLiteral) ? parseLiteralTypeNode(/*negative*/ true) : parseTypeReference();
2931+
return lookAhead(nextTokenIsNumericOrBigIntLiteral) ? parseLiteralTypeNode(/*negative*/ true) : parseTypeReference();
29302932
case SyntaxKind.VoidKeyword:
29312933
case SyntaxKind.NullKeyword:
29322934
return parseTokenNode<TypeNode>();
@@ -2978,6 +2980,7 @@ namespace ts {
29782980
case SyntaxKind.NewKeyword:
29792981
case SyntaxKind.StringLiteral:
29802982
case SyntaxKind.NumericLiteral:
2983+
case SyntaxKind.BigIntLiteral:
29812984
case SyntaxKind.TrueKeyword:
29822985
case SyntaxKind.FalseKeyword:
29832986
case SyntaxKind.ObjectKeyword:
@@ -2991,7 +2994,7 @@ namespace ts {
29912994
case SyntaxKind.FunctionKeyword:
29922995
return !inStartOfParameter;
29932996
case SyntaxKind.MinusToken:
2994-
return !inStartOfParameter && lookAhead(nextTokenIsNumericLiteral);
2997+
return !inStartOfParameter && lookAhead(nextTokenIsNumericOrBigIntLiteral);
29952998
case SyntaxKind.OpenParenToken:
29962999
// Only consider '(' the start of a type if followed by ')', '...', an identifier, a modifier,
29973000
// or something that starts a type. We don't want to consider things like '(1)' a type.
@@ -3216,6 +3219,7 @@ namespace ts {
32163219
case SyntaxKind.TrueKeyword:
32173220
case SyntaxKind.FalseKeyword:
32183221
case SyntaxKind.NumericLiteral:
3222+
case SyntaxKind.BigIntLiteral:
32193223
case SyntaxKind.StringLiteral:
32203224
case SyntaxKind.NoSubstitutionTemplateLiteral:
32213225
case SyntaxKind.TemplateHead:
@@ -4625,6 +4629,7 @@ namespace ts {
46254629
function parsePrimaryExpression(): PrimaryExpression {
46264630
switch (token()) {
46274631
case SyntaxKind.NumericLiteral:
4632+
case SyntaxKind.BigIntLiteral:
46284633
case SyntaxKind.StringLiteral:
46294634
case SyntaxKind.NoSubstitutionTemplateLiteral:
46304635
return parseLiteralNode();
@@ -5140,7 +5145,7 @@ namespace ts {
51405145

51415146
function nextTokenIsIdentifierOrKeywordOrLiteralOnSameLine() {
51425147
nextToken();
5143-
return (tokenIsIdentifierOrKeyword(token()) || token() === SyntaxKind.NumericLiteral || token() === SyntaxKind.StringLiteral) && !scanner.hasPrecedingLineBreak();
5148+
return (tokenIsIdentifierOrKeyword(token()) || token() === SyntaxKind.NumericLiteral || token() === SyntaxKind.BigIntLiteral || token() === SyntaxKind.StringLiteral) && !scanner.hasPrecedingLineBreak();
51445149
}
51455150

51465151
function isDeclaration(): boolean {

0 commit comments

Comments
 (0)