Add TSBigIntKeyword to @babel/types (#10341)

packages/babel-generator/src/generators/typescript.js

@@ -129,6 +129,9 @@ export function TSIndexSignature(node) {
 export function TSAnyKeyword() {
   this.word("any");
 }
+export function TSBigIntKeyword() {
+  this.word("bigint");
+}
 export function TSUnknownKeyword() {
   this.word("unknown");
 }

packages/babel-plugin-transform-typescript/test/fixtures/regression/10338/input.ts

@@ -0,0 +1,4 @@
+const {result} = idArray.reduce(
+  (a, b) => {},
+  {result: [] as (number | bigint)[]},
+)

packages/babel-plugin-transform-typescript/test/fixtures/regression/10338/options.json

@@ -0,0 +1,3 @@
+{
+  "plugins": ["transform-typescript", "transform-destructuring"]
+}

packages/babel-plugin-transform-typescript/test/fixtures/regression/10338/output.js

@@ -0,0 +1,4 @@
+const _idArray$reduce = idArray.reduce((a, b) => {}, {
+  result: []
+}),
+      result = _idArray$reduce.result;

packages/babel-types/src/asserts/generated/index.js

@@ -794,8 +794,17 @@ export function assertTSIndexSignature(node: Object, opts?: Object = {}): void {
 export function assertTSAnyKeyword(node: Object, opts?: Object = {}): void {
   assert("TSAnyKeyword", node, opts);
 }
-export function assertTSUnknownKeyword(node: Object, opts?: Object = {}): void {
-  assert("TSUnknownKeyword", node, opts);
+export function assertTSBooleanKeyword(node: Object, opts?: Object = {}): void {
+  assert("TSBooleanKeyword", node, opts);
+}
+export function assertTSBigIntKeyword(node: Object, opts?: Object = {}): void {
+  assert("TSBigIntKeyword", node, opts);
+}
+export function assertTSNeverKeyword(node: Object, opts?: Object = {}): void {
+  assert("TSNeverKeyword", node, opts);
+}
+export function assertTSNullKeyword(node: Object, opts?: Object = {}): void {
+  assert("TSNullKeyword", node, opts);
 }
 export function assertTSNumberKeyword(node: Object, opts?: Object = {}): void {
   assert("TSNumberKeyword", node, opts);
@@ -803,29 +812,23 @@ export function assertTSNumberKeyword(node: Object, opts?: Object = {}): void {
 export function assertTSObjectKeyword(node: Object, opts?: Object = {}): void {
   assert("TSObjectKeyword", node, opts);
 }
-export function assertTSBooleanKeyword(node: Object, opts?: Object = {}): void {
-  assert("TSBooleanKeyword", node, opts);
-}
 export function assertTSStringKeyword(node: Object, opts?: Object = {}): void {
   assert("TSStringKeyword", node, opts);
 }
 export function assertTSSymbolKeyword(node: Object, opts?: Object = {}): void {
   assert("TSSymbolKeyword", node, opts);
 }
-export function assertTSVoidKeyword(node: Object, opts?: Object = {}): void {
-  assert("TSVoidKeyword", node, opts);
-}
 export function assertTSUndefinedKeyword(
   node: Object,
   opts?: Object = {},
 ): void {
   assert("TSUndefinedKeyword", node, opts);
 }
-export function assertTSNullKeyword(node: Object, opts?: Object = {}): void {
-  assert("TSNullKeyword", node, opts);
+export function assertTSUnknownKeyword(node: Object, opts?: Object = {}): void {
+  assert("TSUnknownKeyword", node, opts);
 }
-export function assertTSNeverKeyword(node: Object, opts?: Object = {}): void {
-  assert("TSNeverKeyword", node, opts);
+export function assertTSVoidKeyword(node: Object, opts?: Object = {}): void {
+  assert("TSVoidKeyword", node, opts);
 }
 export function assertTSThisType(node: Object, opts?: Object = {}): void {
   assert("TSThisType", node, opts);

packages/babel-types/src/builders/generated/index.js

@@ -722,11 +722,26 @@ export function TSAnyKeyword(...args: Array<any>): Object {
 }
 export { TSAnyKeyword as tsAnyKeyword };
 export { TSAnyKeyword as tSAnyKeyword };
-export function TSUnknownKeyword(...args: Array<any>): Object {
-  return builder("TSUnknownKeyword", ...args);
+export function TSBooleanKeyword(...args: Array<any>): Object {
+  return builder("TSBooleanKeyword", ...args);
 }
-export { TSUnknownKeyword as tsUnknownKeyword };
-export { TSUnknownKeyword as tSUnknownKeyword };
+export { TSBooleanKeyword as tsBooleanKeyword };
+export { TSBooleanKeyword as tSBooleanKeyword };
+export function TSBigIntKeyword(...args: Array<any>): Object {
+  return builder("TSBigIntKeyword", ...args);
+}
+export { TSBigIntKeyword as tsBigIntKeyword };
+export { TSBigIntKeyword as tSBigIntKeyword };
+export function TSNeverKeyword(...args: Array<any>): Object {
+  return builder("TSNeverKeyword", ...args);
+}
+export { TSNeverKeyword as tsNeverKeyword };
+export { TSNeverKeyword as tSNeverKeyword };
+export function TSNullKeyword(...args: Array<any>): Object {
+  return builder("TSNullKeyword", ...args);
+}
+export { TSNullKeyword as tsNullKeyword };
+export { TSNullKeyword as tSNullKeyword };
 export function TSNumberKeyword(...args: Array<any>): Object {
   return builder("TSNumberKeyword", ...args);
 }
@@ -737,11 +752,6 @@ export function TSObjectKeyword(...args: Array<any>): Object {
 }
 export { TSObjectKeyword as tsObjectKeyword };
 export { TSObjectKeyword as tSObjectKeyword };
-export function TSBooleanKeyword(...args: Array<any>): Object {
-  return builder("TSBooleanKeyword", ...args);
-}
-export { TSBooleanKeyword as tsBooleanKeyword };
-export { TSBooleanKeyword as tSBooleanKeyword };
 export function TSStringKeyword(...args: Array<any>): Object {
   return builder("TSStringKeyword", ...args);
 }
@@ -752,26 +762,21 @@ export function TSSymbolKeyword(...args: Array<any>): Object {
 }
 export { TSSymbolKeyword as tsSymbolKeyword };
 export { TSSymbolKeyword as tSSymbolKeyword };
-export function TSVoidKeyword(...args: Array<any>): Object {
-  return builder("TSVoidKeyword", ...args);
-}
-export { TSVoidKeyword as tsVoidKeyword };
-export { TSVoidKeyword as tSVoidKeyword };
 export function TSUndefinedKeyword(...args: Array<any>): Object {
   return builder("TSUndefinedKeyword", ...args);
 }
 export { TSUndefinedKeyword as tsUndefinedKeyword };
 export { TSUndefinedKeyword as tSUndefinedKeyword };
-export function TSNullKeyword(...args: Array<any>): Object {
-  return builder("TSNullKeyword", ...args);
+export function TSUnknownKeyword(...args: Array<any>): Object {
+  return builder("TSUnknownKeyword", ...args);
 }
-export { TSNullKeyword as tsNullKeyword };
-export { TSNullKeyword as tSNullKeyword };
-export function TSNeverKeyword(...args: Array<any>): Object {
-  return builder("TSNeverKeyword", ...args);
+export { TSUnknownKeyword as tsUnknownKeyword };
+export { TSUnknownKeyword as tSUnknownKeyword };
+export function TSVoidKeyword(...args: Array<any>): Object {
+  return builder("TSVoidKeyword", ...args);
 }
-export { TSNeverKeyword as tsNeverKeyword };
-export { TSNeverKeyword as tSNeverKeyword };
+export { TSVoidKeyword as tsVoidKeyword };
+export { TSVoidKeyword as tSVoidKeyword };
 export function TSThisType(...args: Array<any>): Object {
   return builder("TSThisType", ...args);
 }

packages/babel-types/src/definitions/typescript.js

@@ -128,16 +128,17 @@ defineType("TSIndexSignature", {
 
 const tsKeywordTypes = [
   "TSAnyKeyword",
-  "TSUnknownKeyword",
+  "TSBooleanKeyword",
+  "TSBigIntKeyword",
+  "TSNeverKeyword",
+  "TSNullKeyword",
   "TSNumberKeyword",
   "TSObjectKeyword",
-  "TSBooleanKeyword",
   "TSStringKeyword",
   "TSSymbolKeyword",
-  "TSVoidKeyword",
   "TSUndefinedKeyword",
-  "TSNullKeyword",
-  "TSNeverKeyword",
+  "TSUnknownKeyword",
+  "TSVoidKeyword",
 ];
 
 for (const type of tsKeywordTypes) {

packages/babel-types/src/validators/generated/index.js

@@ -2523,11 +2523,53 @@ export function isTSAnyKeyword(node: ?Object, opts?: Object): boolean {
 
   return false;
 }
-export function isTSUnknownKeyword(node: ?Object, opts?: Object): boolean {
+export function isTSBooleanKeyword(node: ?Object, opts?: Object): boolean {
   if (!node) return false;
 
   const nodeType = node.type;
-  if (nodeType === "TSUnknownKeyword") {
+  if (nodeType === "TSBooleanKeyword") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return shallowEqual(node, opts);
+    }
+  }
+
+  return false;
+}
+export function isTSBigIntKeyword(node: ?Object, opts?: Object): boolean {
+  if (!node) return false;
+
+  const nodeType = node.type;
+  if (nodeType === "TSBigIntKeyword") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return shallowEqual(node, opts);
+    }
+  }
+
+  return false;
+}
+export function isTSNeverKeyword(node: ?Object, opts?: Object): boolean {
+  if (!node) return false;
+
+  const nodeType = node.type;
+  if (nodeType === "TSNeverKeyword") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return shallowEqual(node, opts);
+    }
+  }
+
+  return false;
+}
+export function isTSNullKeyword(node: ?Object, opts?: Object): boolean {
+  if (!node) return false;
+
+  const nodeType = node.type;
+  if (nodeType === "TSNullKeyword") {
     if (typeof opts === "undefined") {
       return true;
     } else {
@@ -2565,20 +2607,6 @@ export function isTSObjectKeyword(node: ?Object, opts?: Object): boolean {
 
   return false;
 }
-export function isTSBooleanKeyword(node: ?Object, opts?: Object): boolean {
-  if (!node) return false;
-
-  const nodeType = node.type;
-  if (nodeType === "TSBooleanKeyword") {
-    if (typeof opts === "undefined") {
-      return true;
-    } else {
-      return shallowEqual(node, opts);
-    }
-  }
-
-  return false;
-}
 export function isTSStringKeyword(node: ?Object, opts?: Object): boolean {
   if (!node) return false;
 
@@ -2607,20 +2635,6 @@ export function isTSSymbolKeyword(node: ?Object, opts?: Object): boolean {
 
   return false;
 }
-export function isTSVoidKeyword(node: ?Object, opts?: Object): boolean {
-  if (!node) return false;
-
-  const nodeType = node.type;
-  if (nodeType === "TSVoidKeyword") {
-    if (typeof opts === "undefined") {
-      return true;
-    } else {
-      return shallowEqual(node, opts);
-    }
-  }
-
-  return false;
-}
 export function isTSUndefinedKeyword(node: ?Object, opts?: Object): boolean {
   if (!node) return false;
 
@@ -2635,11 +2649,11 @@ export function isTSUndefinedKeyword(node: ?Object, opts?: Object): boolean {
 
   return false;
 }
-export function isTSNullKeyword(node: ?Object, opts?: Object): boolean {
+export function isTSUnknownKeyword(node: ?Object, opts?: Object): boolean {
   if (!node) return false;
 
   const nodeType = node.type;
-  if (nodeType === "TSNullKeyword") {
+  if (nodeType === "TSUnknownKeyword") {
     if (typeof opts === "undefined") {
       return true;
     } else {
@@ -2649,11 +2663,11 @@ export function isTSNullKeyword(node: ?Object, opts?: Object): boolean {
 
   return false;
 }
-export function isTSNeverKeyword(node: ?Object, opts?: Object): boolean {
+export function isTSVoidKeyword(node: ?Object, opts?: Object): boolean {
   if (!node) return false;
 
   const nodeType = node.type;
-  if (nodeType === "TSNeverKeyword") {
+  if (nodeType === "TSVoidKeyword") {
     if (typeof opts === "undefined") {
       return true;
     } else {
@@ -4326,16 +4340,17 @@ export function isTSType(node: ?Object, opts?: Object): boolean {
   if (
     nodeType === "TSType" ||
     "TSAnyKeyword" === nodeType ||
-    "TSUnknownKeyword" === nodeType ||
+    "TSBooleanKeyword" === nodeType ||
+    "TSBigIntKeyword" === nodeType ||
+    "TSNeverKeyword" === nodeType ||
+    "TSNullKeyword" === nodeType ||
     "TSNumberKeyword" === nodeType ||
     "TSObjectKeyword" === nodeType ||
-    "TSBooleanKeyword" === nodeType ||
     "TSStringKeyword" === nodeType ||
     "TSSymbolKeyword" === nodeType ||
-    "TSVoidKeyword" === nodeType ||
     "TSUndefinedKeyword" === nodeType ||
-    "TSNullKeyword" === nodeType ||
-    "TSNeverKeyword" === nodeType ||
+    "TSUnknownKeyword" === nodeType ||
+    "TSVoidKeyword" === nodeType ||
     "TSThisType" === nodeType ||
     "TSFunctionType" === nodeType ||
     "TSConstructorType" === nodeType ||