Skip to content

Commit 74fd6d3

Browse files
calebsandercalebsander
committed
Remove references to bigint in compiler code
1 parent ead2689 commit 74fd6d3

File tree

6 files changed

+48
-48
lines changed

6 files changed

+48
-48
lines changed

‎src/compiler/checker.ts

+24-24
Original file line numberDiff line numberDiff line change
@@ -8948,15 +8948,15 @@ namespace ts {
89488948
type.resolvedIndexType || (type.resolvedIndexType = createIndexType(type, /*stringsOnly*/ false));
89498949
}
89508950

8951-
function guardedBigInt(value: string | number, node?: Node): bigint | number {
8951+
function guardedBigInt(value: string | number, node?: Node): number {
89528952
if (typeof BigInt === "undefined") { // error and fall back to number parsing
89538953
error(node, Diagnostics.Cannot_evaluate_bigint_literal_because_the_compiler_is_running_in_an_environment_without_bigint_support);
89548954
return +value;
89558955
}
89568956
return BigInt(value);
89578957
}
89588958

8959-
function getNumericLiteralValue(node: NumericLiteral): number | bigint {
8959+
function getNumericLiteralValue(node: NumericLiteral): number {
89608960
return node.numericLiteralFlags & TokenFlags.BigInt
89618961
? guardedBigInt(node.text.slice(0, -1), node) // leave off trailing "n"
89628962
: +node.text;
@@ -9639,7 +9639,7 @@ namespace ts {
96399639
return prop.flags & SymbolFlags.Method && find(prop.declarations, decl => isClassLike(decl.parent));
96409640
}
96419641

9642-
function createLiteralType(flags: TypeFlags, value: string | number | bigint, symbol: Symbol | undefined) {
9642+
function createLiteralType(flags: TypeFlags, value: string | number, symbol: Symbol | undefined) {
96439643
const type = <LiteralType>createType(flags);
96449644
type.symbol = symbol!;
96459645
type.value = value;
@@ -9664,17 +9664,17 @@ namespace ts {
96649664
type;
96659665
}
96669666

9667-
function getLiteralType(value: string | number | bigint, enumId?: number, symbol?: Symbol) {
9667+
function getLiteralType(value: string | number, enumId?: number, symbol?: Symbol) {
96689668
// We store all literal types in a single map with keys of the form '#NNN' and '@SSS',
96699669
// where NNN is the text representation of a numeric literal and SSS are the characters
96709670
// of a string literal. For literal enum members we use 'EEE#NNN' and 'EEE@SSS', where
96719671
// EEE is a unique id for the containing enum type.
9672-
const qualifier = typeof value === "number" ? "#" : typeof value === "bigint" ? "n" : "@";
9672+
const qualifier = typeof value === "number" ? "#" : typeof value as string === "bigint" ? "n" : "@";
96739673
const key = enumId ? enumId + qualifier + value : qualifier + value;
96749674
let type = literalTypes.get(key);
96759675
if (!type) {
96769676
const flags = (typeof value === "number" ? TypeFlags.NumberLiteral :
9677-
typeof value === "bigint" ? TypeFlags.BigIntLiteral : TypeFlags.StringLiteral) |
9677+
typeof value as string === "bigint" ? TypeFlags.BigIntLiteral : TypeFlags.StringLiteral) |
96789678
(enumId ? TypeFlags.EnumLiteral : 0);
96799679
literalTypes.set(key, type = createLiteralType(flags, value, symbol));
96809680
}
@@ -25761,7 +25761,7 @@ namespace ts {
2576125761
const initializer = member.initializer!;
2576225762
let value = enumKind === EnumKind.Literal && !isLiteralEnumMember(member) ? undefined : evaluate(initializer);
2576325763
if (value !== undefined) {
25764-
if (typeof value === "bigint") {
25764+
if (typeof value as string === "bigint") {
2576525765
value = Number(value);
2576625766
}
2576725767
if (isConstEnum && typeof value === "number" && !isFinite(value)) {
@@ -25786,20 +25786,20 @@ namespace ts {
2578625786
}
2578725787
return value;
2578825788

25789-
function evaluate(expr: Expression): string | number | bigint | undefined {
25789+
function evaluate(expr: Expression): string | number | undefined {
2579025790
switch (expr.kind) {
2579125791
case SyntaxKind.PrefixUnaryExpression:
2579225792
const value = evaluate((<PrefixUnaryExpression>expr).operand);
25793-
if (typeof value === "number" || typeof value === "bigint") {
25793+
if (typeof value === "number" || typeof value as string === "bigint") {
2579425794
switch ((<PrefixUnaryExpression>expr).operator) {
2579525795
case SyntaxKind.PlusToken:
25796-
if (typeof value === "bigint") {
25796+
if (typeof value as string === "bigint") {
2579725797
error(expr, Diagnostics.Operator_0_cannot_be_applied_to_type_1, tokenToString(SyntaxKind.PlusToken), typeToString(bigintType));
2579825798
return undefined;
2579925799
}
2580025800
return value;
25801-
case SyntaxKind.MinusToken: return -value;
25802-
case SyntaxKind.TildeToken: return ~value;
25801+
case SyntaxKind.MinusToken: return -<number>value;
25802+
case SyntaxKind.TildeToken: return ~<number>value;
2580325803
}
2580425804
}
2580525805
break;
@@ -25822,19 +25822,19 @@ namespace ts {
2582225822
case SyntaxKind.AsteriskAsteriskToken: return left ** right;
2582325823
}
2582425824
}
25825-
else if (typeof left === "bigint" && typeof right === "bigint") {
25825+
else if (typeof left as string === "bigint" && typeof right as string === "bigint") {
2582625826
switch ((<BinaryExpression>expr).operatorToken.kind) {
25827-
case SyntaxKind.BarToken: return left | right;
25828-
case SyntaxKind.AmpersandToken: return left & right;
25829-
case SyntaxKind.GreaterThanGreaterThanToken: return left >> right;
25830-
case SyntaxKind.LessThanLessThanToken: return left << right;
25831-
case SyntaxKind.CaretToken: return left ^ right;
25832-
case SyntaxKind.AsteriskToken: return left * right;
25833-
case SyntaxKind.SlashToken: return left / right;
25834-
case SyntaxKind.PlusToken: return left + right;
25835-
case SyntaxKind.MinusToken: return left - right;
25836-
case SyntaxKind.PercentToken: return left % right;
25837-
case SyntaxKind.AsteriskAsteriskToken: return left ** right;
25827+
case SyntaxKind.BarToken: return <number>left | <number>right;
25828+
case SyntaxKind.AmpersandToken: return <number>left & <number>right;
25829+
case SyntaxKind.GreaterThanGreaterThanToken: return <number>left >> <number>right;
25830+
case SyntaxKind.LessThanLessThanToken: return <number>left << <number>right;
25831+
case SyntaxKind.CaretToken: return <number>left ^ <number>right;
25832+
case SyntaxKind.AsteriskToken: return <number>left * <number>right;
25833+
case SyntaxKind.SlashToken: return <number>left / <number>right;
25834+
case SyntaxKind.PlusToken: return <number>left + <number>right;
25835+
case SyntaxKind.MinusToken: return <number>left - <number>right;
25836+
case SyntaxKind.PercentToken: return <number>left % <number>right;
25837+
case SyntaxKind.AsteriskAsteriskToken: return (<number>left) ** <number>right;
2583825838
}
2583925839
}
2584025840
else if (typeof left === "string" && typeof right === "string" && (<BinaryExpression>expr).operatorToken.kind === SyntaxKind.PlusToken) {

‎src/compiler/factory.ts

+4-4
Original file line numberDiff line numberDiff line change
@@ -68,14 +68,14 @@ namespace ts {
6868
/* @internal */ export function createLiteral(value: string | StringLiteral | NoSubstitutionTemplateLiteral | NumericLiteral | Identifier, isSingleQuote: boolean): StringLiteral; // tslint:disable-line unified-signatures
6969
/** If a node is passed, creates a string literal whose source text is read from a source node during emit. */
7070
export function createLiteral(value: string | StringLiteral | NoSubstitutionTemplateLiteral | NumericLiteral | Identifier): StringLiteral;
71-
export function createLiteral(value: number | bigint): NumericLiteral;
71+
export function createLiteral(value: number): NumericLiteral;
7272
export function createLiteral(value: boolean): BooleanLiteral;
73-
export function createLiteral(value: string | number | bigint | boolean): PrimaryExpression;
74-
export function createLiteral(value: string | number | bigint | boolean | StringLiteral | NoSubstitutionTemplateLiteral | NumericLiteral | Identifier, isSingleQuote?: boolean): PrimaryExpression {
73+
export function createLiteral(value: string | number | boolean): PrimaryExpression;
74+
export function createLiteral(value: string | number | boolean | StringLiteral | NoSubstitutionTemplateLiteral | NumericLiteral | Identifier, isSingleQuote?: boolean): PrimaryExpression {
7575
if (typeof value === "number") {
7676
return createNumericLiteral(value + "");
7777
}
78-
if (typeof value === "bigint") {
78+
if (typeof value as string === "bigint") {
7979
const literal = createNumericLiteral(value + "n");
8080
literal.numericLiteralFlags |= TokenFlags.BigInt;
8181
return literal;

‎src/compiler/types.ts

+5-5
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,5 @@
11
// TODO: remove once tslint allows tsconfig.json to include lib "esnext.bigint"
2-
declare const BigInt: ((value: number | string) => bigint) | undefined;
2+
declare const BigInt: ((value: number | string) => number) | undefined;
33

44
namespace ts {
55
// branded string type used to store absolute, normalized and canonicalized paths
@@ -3775,9 +3775,9 @@ namespace ts {
37753775
// Numeric literal types (TypeFlags.NumberLiteral)
37763776
// BigInt literal types (TypeFlags.BigIntLiteral)
37773777
export interface LiteralType extends Type {
3778-
value: string | number | bigint; // Value of literal
3779-
freshType: LiteralType; // Fresh version of type
3780-
regularType: LiteralType; // Regular version of type
3778+
value: string | number; // Value of literal
3779+
freshType: LiteralType; // Fresh version of type
3780+
regularType: LiteralType; // Regular version of type
37813781
}
37823782

37833783
// Unique symbol types (TypeFlags.UniqueESSymbol)
@@ -3794,7 +3794,7 @@ namespace ts {
37943794
}
37953795

37963796
export interface BigIntLiteralType extends LiteralType {
3797-
value: bigint;
3797+
value: number;
37983798
}
37993799

38003800
// Enum types (TypeFlags.Enum)

‎src/services/completions.ts

+5-5
Original file line numberDiff line numberDiff line change
@@ -198,9 +198,9 @@ namespace ts.Completions {
198198
});
199199
}
200200

201-
const completionNameForLiteral = (literal: string | number | bigint) =>
202-
typeof literal === "bigint" ? literal + "n" : JSON.stringify(literal);
203-
function createCompletionEntryForLiteral(literal: string | number | bigint): CompletionEntry {
201+
const completionNameForLiteral = (literal: string | number) =>
202+
typeof literal as string === "bigint" ? literal + "n" : JSON.stringify(literal);
203+
function createCompletionEntryForLiteral(literal: string | number): CompletionEntry {
204204
return { name: completionNameForLiteral(literal), kind: ScriptElementKind.string, kindModifiers: ScriptElementKindModifier.none, sortText: "0" };
205205
}
206206

@@ -511,7 +511,7 @@ namespace ts.Completions {
511511
readonly isJsxInitializer: IsJsxInitializer;
512512
}
513513
function getSymbolCompletionFromEntryId(program: Program, log: Log, sourceFile: SourceFile, position: number, entryId: CompletionEntryIdentifier,
514-
): SymbolCompletion | { type: "request", request: Request } | { type: "literal", literal: string | number | bigint } | { type: "none" } {
514+
): SymbolCompletion | { type: "request", request: Request } | { type: "literal", literal: string | number } | { type: "none" } {
515515
const compilerOptions = program.getCompilerOptions();
516516
const completionData = getCompletionData(program, log, sourceFile, isUncheckedFile(sourceFile, compilerOptions), position, { includeCompletionsForModuleExports: true, includeCompletionsWithInsertText: true }, entryId);
517517
if (!completionData) {
@@ -698,7 +698,7 @@ namespace ts.Completions {
698698
readonly isNewIdentifierLocation: boolean;
699699
readonly location: Node | undefined;
700700
readonly keywordFilters: KeywordCompletionFilters;
701-
readonly literals: ReadonlyArray<string | number | bigint>;
701+
readonly literals: ReadonlyArray<string | number>;
702702
readonly symbolToOriginInfoMap: SymbolOriginInfoMap;
703703
readonly recommendedCompletion: Symbol | undefined;
704704
readonly previousToken: Node | undefined;

‎tests/baselines/reference/api/tsserverlibrary.d.ts

+5-5
Original file line numberDiff line numberDiff line change
@@ -61,7 +61,7 @@ declare namespace ts {
6161
push(...values: T[]): void;
6262
}
6363
}
64-
declare const BigInt: ((value: number | string) => bigint) | undefined;
64+
declare const BigInt: ((value: number | string) => number) | undefined;
6565
declare namespace ts {
6666
type Path = string & {
6767
__pathBrand: any;
@@ -2198,7 +2198,7 @@ declare namespace ts {
21982198
aliasTypeArguments?: ReadonlyArray<Type>;
21992199
}
22002200
interface LiteralType extends Type {
2201-
value: string | number | bigint;
2201+
value: string | number;
22022202
freshType: LiteralType;
22032203
regularType: LiteralType;
22042204
}
@@ -2212,7 +2212,7 @@ declare namespace ts {
22122212
value: number;
22132213
}
22142214
interface BigIntLiteralType extends LiteralType {
2215-
value: bigint;
2215+
value: number;
22162216
}
22172217
interface EnumType extends Type {
22182218
}
@@ -3621,9 +3621,9 @@ declare namespace ts {
36213621
function createNodeArray<T extends Node>(elements?: ReadonlyArray<T>, hasTrailingComma?: boolean): NodeArray<T>;
36223622
/** If a node is passed, creates a string literal whose source text is read from a source node during emit. */
36233623
function createLiteral(value: string | StringLiteral | NoSubstitutionTemplateLiteral | NumericLiteral | Identifier): StringLiteral;
3624-
function createLiteral(value: number | bigint): NumericLiteral;
3624+
function createLiteral(value: number): NumericLiteral;
36253625
function createLiteral(value: boolean): BooleanLiteral;
3626-
function createLiteral(value: string | number | bigint | boolean): PrimaryExpression;
3626+
function createLiteral(value: string | number | boolean): PrimaryExpression;
36273627
function createNumericLiteral(value: string): NumericLiteral;
36283628
function createStringLiteral(text: string): StringLiteral;
36293629
function createRegularExpressionLiteral(text: string): RegularExpressionLiteral;

‎tests/baselines/reference/api/typescript.d.ts

+5-5
Original file line numberDiff line numberDiff line change
@@ -61,7 +61,7 @@ declare namespace ts {
6161
push(...values: T[]): void;
6262
}
6363
}
64-
declare const BigInt: ((value: number | string) => bigint) | undefined;
64+
declare const BigInt: ((value: number | string) => number) | undefined;
6565
declare namespace ts {
6666
type Path = string & {
6767
__pathBrand: any;
@@ -2198,7 +2198,7 @@ declare namespace ts {
21982198
aliasTypeArguments?: ReadonlyArray<Type>;
21992199
}
22002200
interface LiteralType extends Type {
2201-
value: string | number | bigint;
2201+
value: string | number;
22022202
freshType: LiteralType;
22032203
regularType: LiteralType;
22042204
}
@@ -2212,7 +2212,7 @@ declare namespace ts {
22122212
value: number;
22132213
}
22142214
interface BigIntLiteralType extends LiteralType {
2215-
value: bigint;
2215+
value: number;
22162216
}
22172217
interface EnumType extends Type {
22182218
}
@@ -3621,9 +3621,9 @@ declare namespace ts {
36213621
function createNodeArray<T extends Node>(elements?: ReadonlyArray<T>, hasTrailingComma?: boolean): NodeArray<T>;
36223622
/** If a node is passed, creates a string literal whose source text is read from a source node during emit. */
36233623
function createLiteral(value: string | StringLiteral | NoSubstitutionTemplateLiteral | NumericLiteral | Identifier): StringLiteral;
3624-
function createLiteral(value: number | bigint): NumericLiteral;
3624+
function createLiteral(value: number): NumericLiteral;
36253625
function createLiteral(value: boolean): BooleanLiteral;
3626-
function createLiteral(value: string | number | bigint | boolean): PrimaryExpression;
3626+
function createLiteral(value: string | number | boolean): PrimaryExpression;
36273627
function createNumericLiteral(value: string): NumericLiteral;
36283628
function createStringLiteral(text: string): StringLiteral;
36293629
function createRegularExpressionLiteral(text: string): RegularExpressionLiteral;

0 commit comments

Comments
 (0)