Add TSSatisfiesExpression to types and generator

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

@@ -496,15 +496,23 @@ export function TSTypeAliasDeclaration(
   this.token(";");
 }
 
-export function TSAsExpression(this: Printer, node: t.TSAsExpression) {
-  const { expression, typeAnnotation } = node;
+function TSTypeExpression(
+  this: Printer,
+  node: t.TSAsExpression | t.TSSatisfiesExpression,
+) {
+  const { type, expression, typeAnnotation } = node;
   this.print(expression, node);
   this.space();
-  this.word("as");
+  this.word(type === "TSAsExpression" ? "as" : "satisfies");
   this.space();
   this.print(typeAnnotation, node);
 }
 
+export {
+  TSTypeExpression as TSAsExpression,
+  TSTypeExpression as TSSatisfiesExpression,
+};
+
 export function TSTypeAssertion(this: Printer, node: t.TSTypeAssertion) {
   const { typeAnnotation, expression } = node;
   this.token("<");

packages/babel-generator/src/node/parentheses.ts

@@ -46,6 +46,7 @@ import {
   isVariableDeclarator,
   isWhileStatement,
   isYieldExpression,
+  isTSSatisfiesExpression,
 } from "@babel/types";
 import type * as t from "@babel/types";
 const PRECEDENCE = {
@@ -197,9 +198,10 @@ export function TSAsExpression() {
   return true;
 }
 
-export function TSTypeAssertion() {
-  return true;
-}
+export {
+  TSAsExpression as TSSatisfiesExpression,
+  TSAsExpression as TSTypeAssertion,
+};
 
 export function TSUnionType(node: any, parent: any): boolean {
   return (
@@ -302,7 +304,8 @@ export function ConditionalExpression(node: any, parent?): boolean {
     isConditionalExpression(parent, { test: node }) ||
     isAwaitExpression(parent) ||
     isTSTypeAssertion(parent) ||
-    isTSAsExpression(parent)
+    isTSAsExpression(parent) ||
+    isTSSatisfiesExpression(parent)
   ) {
     return true;
   }

packages/babel-generator/test/fixtures/typescript/satisfies/input.js

@@ -0,0 +1,4 @@
+x satisfies T;
+x < y satisfies boolean; // (x < y) satisfies boolean;
+x === 1 satisfies number; // x === (1 satisfies number);
+x satisfies any satisfies T;

packages/babel-generator/test/fixtures/typescript/satisfies/output.js

@@ -0,0 +1,6 @@
+(x satisfies T);
+(x < y satisfies boolean); // (x < y) satisfies boolean;
+
+x === (1 satisfies number); // x === (1 satisfies number);
+
+((x satisfies any) satisfies T);

packages/babel-traverse/src/path/generated/asserts.ts

@@ -570,6 +570,9 @@ export interface NodePathAssetions {
     opts?: object,
   ): asserts this is NodePath<t.TSQualifiedName>;
   assertTSRestType(opts?: object): asserts this is NodePath<t.TSRestType>;
+  assertTSSatisfiesExpression(
+    opts?: object,
+  ): asserts this is NodePath<t.TSSatisfiesExpression>;
   assertTSStringKeyword(
     opts?: object,
   ): asserts this is NodePath<t.TSStringKeyword>;

packages/babel-traverse/src/path/generated/validators.ts

@@ -351,6 +351,9 @@ export interface NodePathValidators {
   isTSPropertySignature(opts?: object): this is NodePath<t.TSPropertySignature>;
   isTSQualifiedName(opts?: object): this is NodePath<t.TSQualifiedName>;
   isTSRestType(opts?: object): this is NodePath<t.TSRestType>;
+  isTSSatisfiesExpression(
+    opts?: object,
+  ): this is NodePath<t.TSSatisfiesExpression>;
   isTSStringKeyword(opts?: object): this is NodePath<t.TSStringKeyword>;
   isTSSymbolKeyword(opts?: object): this is NodePath<t.TSSymbolKeyword>;
   isTSThisType(opts?: object): this is NodePath<t.TSThisType>;

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

@@ -1400,6 +1400,12 @@ export function assertTSAsExpression(
 ): asserts node is t.TSAsExpression {
   assert("TSAsExpression", node, opts);
 }
+export function assertTSSatisfiesExpression(
+  node: object | null | undefined,
+  opts?: object | null,
+): asserts node is t.TSSatisfiesExpression {
+  assert("TSSatisfiesExpression", node, opts);
+}
 export function assertTSTypeAssertion(
   node: object | null | undefined,
   opts?: object | null,

packages/babel-types/src/ast-types/generated/index.ts

@@ -249,6 +249,7 @@ export type Node =
   | TSPropertySignature
   | TSQualifiedName
   | TSRestType
+  | TSSatisfiesExpression
   | TSStringKeyword
   | TSSymbolKeyword
   | TSThisType
@@ -1920,6 +1921,12 @@ export interface TSAsExpression extends BaseNode {
   typeAnnotation: TSType;
 }
 
+export interface TSSatisfiesExpression extends BaseNode {
+  type: "TSSatisfiesExpression";
+  expression: Expression;
+  typeAnnotation: TSType;
+}
+
 export interface TSTypeAssertion extends BaseNode {
   type: "TSTypeAssertion";
   typeAnnotation: TSType;
@@ -2146,6 +2153,7 @@ export type Expression =
   | PipelineBareFunction
   | PipelinePrimaryTopicReference
   | TSAsExpression
+  | TSSatisfiesExpression
   | TSTypeAssertion
   | TSNonNullExpression;
 export type Binary = BinaryExpression | LogicalExpression;
@@ -2582,6 +2590,7 @@ export type TypeScript =
   | TSInterfaceBody
   | TSTypeAliasDeclaration
   | TSAsExpression
+  | TSSatisfiesExpression
   | TSTypeAssertion
   | TSEnumDeclaration
   | TSEnumMember

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

@@ -1374,6 +1374,13 @@ export function tsAsExpression(
   return builder.apply("TSAsExpression", arguments);
 }
 export { tsAsExpression as tSAsExpression };
+export function tsSatisfiesExpression(
+  expression: t.Expression,
+  typeAnnotation: t.TSType,
+): t.TSSatisfiesExpression {
+  return builder.apply("TSSatisfiesExpression", arguments);
+}
+export { tsSatisfiesExpression as tSSatisfiesExpression };
 export function tsTypeAssertion(
   typeAnnotation: t.TSType,
   expression: t.Expression,

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

@@ -240,6 +240,7 @@ export {
   tsInterfaceBody as TSInterfaceBody,
   tsTypeAliasDeclaration as TSTypeAliasDeclaration,
   tsAsExpression as TSAsExpression,
+  tsSatisfiesExpression as TSSatisfiesExpression,
   tsTypeAssertion as TSTypeAssertion,
   tsEnumDeclaration as TSEnumDeclaration,
   tsEnumMember as TSEnumMember,

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

@@ -449,14 +449,17 @@ defineType("TSTypeAliasDeclaration", {
   },
 });
 
-defineType("TSAsExpression", {
+const TSTypeExpression = {
   aliases: ["Expression"],
   visitor: ["expression", "typeAnnotation"],
   fields: {
     expression: validateType("Expression"),
     typeAnnotation: validateType("TSType"),
   },
-});
+};
+
+defineType("TSAsExpression", TSTypeExpression);
+defineType("TSSatisfiesExpression", TSTypeExpression);
 
 defineType("TSTypeAssertion", {
   aliases: ["Expression"],

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

@@ -3932,6 +3932,23 @@ export function isTSAsExpression(
 
   return false;
 }
+export function isTSSatisfiesExpression(
+  node: object | null | undefined,
+  opts?: object | null,
+): node is t.TSSatisfiesExpression {
+  if (!node) return false;
+
+  const nodeType = (node as t.Node).type;
+  if (nodeType === "TSSatisfiesExpression") {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return shallowEqual(node, opts);
+    }
+  }
+
+  return false;
+}
 export function isTSTypeAssertion(
   node: object | null | undefined,
   opts?: object | null,
@@ -4351,6 +4368,7 @@ export function isExpression(
     "PipelineBareFunction" === nodeType ||
     "PipelinePrimaryTopicReference" === nodeType ||
     "TSAsExpression" === nodeType ||
+    "TSSatisfiesExpression" === nodeType ||
     "TSTypeAssertion" === nodeType ||
     "TSNonNullExpression" === nodeType ||
     (nodeType === "Placeholder" &&
@@ -5565,6 +5583,7 @@ export function isTypeScript(
     "TSInterfaceBody" === nodeType ||
     "TSTypeAliasDeclaration" === nodeType ||
     "TSAsExpression" === nodeType ||
+    "TSSatisfiesExpression" === nodeType ||
     "TSTypeAssertion" === nodeType ||
     "TSEnumDeclaration" === nodeType ||
     "TSEnumMember" === nodeType ||