hermes-transform 0.15.1 → 0.17.0

package/dist/generated/TransformCloneSignatures.js.flow

@@ -27,6 +27,7 @@ import type {
   ArrayPattern,
   ArrayTypeAnnotation,
   ArrowFunctionExpression,
+  AsExpression,
   AssignmentExpression,
   AssignmentPattern,
   AwaitExpression,
@@ -179,6 +180,7 @@ import type {
   TypeAnnotation,
   TypeCastExpression,
   TypeofTypeAnnotation,
+  TypeOperator,
   TypeParameter,
   TypeParameterDeclaration,
   TypeParameterInstantiation,
@@ -200,6 +202,7 @@ import type {
   ArrayPatternProps,
   ArrayTypeAnnotationProps,
   ArrowFunctionExpressionProps,
+  AsExpressionProps,
   AssignmentExpressionProps,
   AssignmentPatternProps,
   AwaitExpressionProps,
@@ -352,6 +355,7 @@ import type {
   TypeAnnotationProps,
   TypeCastExpressionProps,
   TypeofTypeAnnotationProps,
+  TypeOperatorProps,
   TypeParameterProps,
   TypeParameterDeclarationProps,
   TypeParameterInstantiationProps,
@@ -409,6 +413,14 @@ type ArrowFunctionExpressionCloneSignature = ((
     node: ?ArrowFunctionExpression,
     newProps: Partial<ArrowFunctionExpressionProps>,
   ) => DetachedNode<ArrowFunctionExpression> | null);
+type AsExpressionCloneSignature = ((
+  node: AsExpression,
+  newProps: Partial<AsExpressionProps>,
+) => DetachedNode<AsExpression>) &
+  ((
+    node: ?AsExpression,
+    newProps: Partial<AsExpressionProps>,
+  ) => DetachedNode<AsExpression> | null);
 type AssignmentExpressionCloneSignature = ((
   node: AssignmentExpression,
   newProps: Partial<AssignmentExpressionProps>,
@@ -1622,6 +1634,14 @@ type TypeofTypeAnnotationCloneSignature = ((
     node: ?TypeofTypeAnnotation,
     newProps: Partial<TypeofTypeAnnotationProps>,
   ) => DetachedNode<TypeofTypeAnnotation> | null);
+type TypeOperatorCloneSignature = ((
+  node: TypeOperator,
+  newProps: Partial<TypeOperatorProps>,
+) => DetachedNode<TypeOperator>) &
+  ((
+    node: ?TypeOperator,
+    newProps: Partial<TypeOperatorProps>,
+  ) => DetachedNode<TypeOperator> | null);
 type TypeParameterCloneSignature = ((
   node: TypeParameter,
   newProps: Partial<TypeParameterProps>,
@@ -1739,6 +1759,7 @@ export type TransformCloneSignatures = AnyTypeAnnotationCloneSignature &
   ArrayPatternCloneSignature &
   ArrayTypeAnnotationCloneSignature &
   ArrowFunctionExpressionCloneSignature &
+  AsExpressionCloneSignature &
   AssignmentExpressionCloneSignature &
   AssignmentPatternCloneSignature &
   AwaitExpressionCloneSignature &
@@ -1891,6 +1912,7 @@ export type TransformCloneSignatures = AnyTypeAnnotationCloneSignature &
   TypeAnnotationCloneSignature &
   TypeCastExpressionCloneSignature &
   TypeofTypeAnnotationCloneSignature &
+  TypeOperatorCloneSignature &
   TypeParameterCloneSignature &
   TypeParameterDeclarationCloneSignature &
   TypeParameterInstantiationCloneSignature &

package/dist/generated/TransformModifySignatures.js.flow

@@ -27,6 +27,7 @@ import type {
   ArrayPattern,
   ArrayTypeAnnotation,
   ArrowFunctionExpression,
+  AsExpression,
   AssignmentExpression,
   AssignmentPattern,
   AwaitExpression,
@@ -179,6 +180,7 @@ import type {
   TypeAnnotation,
   TypeCastExpression,
   TypeofTypeAnnotation,
+  TypeOperator,
   TypeParameter,
   TypeParameterDeclaration,
   TypeParameterInstantiation,
@@ -200,6 +202,7 @@ import type {
   ArrayPatternProps,
   ArrayTypeAnnotationProps,
   ArrowFunctionExpressionProps,
+  AsExpressionProps,
   AssignmentExpressionProps,
   AssignmentPatternProps,
   AwaitExpressionProps,
@@ -352,6 +355,7 @@ import type {
   TypeAnnotationProps,
   TypeCastExpressionProps,
   TypeofTypeAnnotationProps,
+  TypeOperatorProps,
   TypeParameterProps,
   TypeParameterDeclarationProps,
   TypeParameterInstantiationProps,
@@ -388,6 +392,10 @@ type ArrowFunctionExpressionModifySignature = (
   node: ?ArrowFunctionExpression,
   newProps: Partial<ArrowFunctionExpressionProps>,
 ) => void;
+type AsExpressionModifySignature = (
+  node: ?AsExpression,
+  newProps: Partial<AsExpressionProps>,
+) => void;
 type AssignmentExpressionModifySignature = (
   node: ?AssignmentExpression,
   newProps: Partial<AssignmentExpressionProps>,
@@ -996,6 +1004,10 @@ type TypeofTypeAnnotationModifySignature = (
   node: ?TypeofTypeAnnotation,
   newProps: Partial<TypeofTypeAnnotationProps>,
 ) => void;
+type TypeOperatorModifySignature = (
+  node: ?TypeOperator,
+  newProps: Partial<TypeOperatorProps>,
+) => void;
 type TypeParameterModifySignature = (
   node: ?TypeParameter,
   newProps: Partial<TypeParameterProps>,
@@ -1057,6 +1069,7 @@ export type TransformModifySignatures = AnyTypeAnnotationModifySignature &
   ArrayPatternModifySignature &
   ArrayTypeAnnotationModifySignature &
   ArrowFunctionExpressionModifySignature &
+  AsExpressionModifySignature &
   AssignmentExpressionModifySignature &
   AssignmentPatternModifySignature &
   AwaitExpressionModifySignature &
@@ -1209,6 +1222,7 @@ export type TransformModifySignatures = AnyTypeAnnotationModifySignature &
   TypeAnnotationModifySignature &
   TypeCastExpressionModifySignature &
   TypeofTypeAnnotationModifySignature &
+  TypeOperatorModifySignature &
   TypeParameterModifySignature &
   TypeParameterDeclarationModifySignature &
   TypeParameterInstantiationModifySignature &

package/dist/generated/TransformReplaceSignatures.js.flow

@@ -27,6 +27,7 @@ import type {
   ArrayPattern,
   ArrayTypeAnnotation,
   ArrowFunctionExpression,
+  AsExpression,
   AssignmentExpression,
   AssignmentPattern,
   AwaitExpression,
@@ -174,6 +175,7 @@ import type {
   TypeAnnotation,
   TypeCastExpression,
   TypeofTypeAnnotation,
+  TypeOperator,
   TypeParameter,
   TypeParameterDeclaration,
   TypeParameterInstantiation,
@@ -217,6 +219,11 @@ type ArrowFunctionExpressionReplaceSignature = (
   nodeToReplaceWith: DetachedNode<ArrowFunctionExpression>,
   options?: $ReadOnly<{keepComments?: boolean}>,
 ) => void;
+type AsExpressionReplaceSignature = (
+  target: AsExpression,
+  nodeToReplaceWith: DetachedNode<AsExpression>,
+  options?: $ReadOnly<{keepComments?: boolean}>,
+) => void;
 type AssignmentExpressionReplaceSignature = (
   target: AssignmentExpression,
   nodeToReplaceWith: DetachedNode<AssignmentExpression>,
@@ -952,6 +959,11 @@ type TypeofTypeAnnotationReplaceSignature = (
   nodeToReplaceWith: DetachedNode<TypeofTypeAnnotation>,
   options?: $ReadOnly<{keepComments?: boolean}>,
 ) => void;
+type TypeOperatorReplaceSignature = (
+  target: TypeOperator,
+  nodeToReplaceWith: DetachedNode<TypeOperator>,
+  options?: $ReadOnly<{keepComments?: boolean}>,
+) => void;
 type TypeParameterReplaceSignature = (
   target: TypeParameter,
   nodeToReplaceWith: DetachedNode<TypeParameter>,
@@ -1032,6 +1044,7 @@ export type TransformReplaceSignatures = AnyTypeAnnotationReplaceSignature &
   ArrayPatternReplaceSignature &
   ArrayTypeAnnotationReplaceSignature &
   ArrowFunctionExpressionReplaceSignature &
+  AsExpressionReplaceSignature &
   AssignmentExpressionReplaceSignature &
   AssignmentPatternReplaceSignature &
   AwaitExpressionReplaceSignature &
@@ -1179,6 +1192,7 @@ export type TransformReplaceSignatures = AnyTypeAnnotationReplaceSignature &
   TypeAnnotationReplaceSignature &
   TypeCastExpressionReplaceSignature &
   TypeofTypeAnnotationReplaceSignature &
+  TypeOperatorReplaceSignature &
   TypeParameterReplaceSignature &
   TypeParameterDeclarationReplaceSignature &
   TypeParameterInstantiationReplaceSignature &

package/dist/generated/node-types.js

@@ -29,6 +29,7 @@ var _exportNames = {
   ArrayExpression: true,
   ArrayPattern: true,
   ArrayTypeAnnotation: true,
+  AsExpression: true,
   AssignmentExpression: true,
   AssignmentPattern: true,
   AwaitExpression: true,
@@ -167,6 +168,7 @@ var _exportNames = {
   TypeAnnotation: true,
   TypeCastExpression: true,
   TypeofTypeAnnotation: true,
+  TypeOperator: true,
   TypeParameter: true,
   TypeParameterDeclaration: true,
   TypeParameterInstantiation: true,
@@ -186,6 +188,7 @@ exports.AnyTypeAnnotation = AnyTypeAnnotation;
 exports.ArrayExpression = ArrayExpression;
 exports.ArrayPattern = ArrayPattern;
 exports.ArrayTypeAnnotation = ArrayTypeAnnotation;
+exports.AsExpression = AsExpression;
 exports.AssignmentExpression = AssignmentExpression;
 exports.AssignmentPattern = AssignmentPattern;
 exports.AwaitExpression = AwaitExpression;
@@ -323,6 +326,7 @@ exports.TupleTypeSpreadElement = TupleTypeSpreadElement;
 exports.TypeAlias = TypeAlias;
 exports.TypeAnnotation = TypeAnnotation;
 exports.TypeCastExpression = TypeCastExpression;
+exports.TypeOperator = TypeOperator;
 exports.TypeParameter = TypeParameter;
 exports.TypeParameterDeclaration = TypeParameterDeclaration;
 exports.TypeParameterInstantiation = TypeParameterInstantiation;
@@ -386,6 +390,16 @@ function ArrayTypeAnnotation(props) {
   return node;
 }
 
+function AsExpression(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
+    type: 'AsExpression',
+    expression: (0, _detachedNode.asDetachedNodeForCodeGen)(props.expression),
+    typeAnnotation: (0, _detachedNode.asDetachedNodeForCodeGen)(props.typeAnnotation)
+  });
+  (0, _detachedNode.setParentPointersInDirectChildren)(node);
+  return node;
+}
+
 function AssignmentExpression(props) {
   const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'AssignmentExpression',
@@ -1781,6 +1795,16 @@ function TypeofTypeAnnotation(props) {
   return node;
 }
 
+function TypeOperator(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
+    type: 'TypeOperator',
+    operator: props.operator,
+    typeAnnotation: (0, _detachedNode.asDetachedNodeForCodeGen)(props.typeAnnotation)
+  });
+  (0, _detachedNode.setParentPointersInDirectChildren)(node);
+  return node;
+}
+
 function TypeParameter(props) {
   const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'TypeParameter',

package/dist/generated/node-types.js.flow

@@ -27,6 +27,7 @@ import type {
   ArrayExpression as ArrayExpressionType,
   ArrayPattern as ArrayPatternType,
   ArrayTypeAnnotation as ArrayTypeAnnotationType,
+  AsExpression as AsExpressionType,
   AssignmentExpression as AssignmentExpressionType,
   AssignmentPattern as AssignmentPatternType,
   AwaitExpression as AwaitExpressionType,
@@ -165,6 +166,7 @@ import type {
   TypeAnnotation as TypeAnnotationType,
   TypeCastExpression as TypeCastExpressionType,
   TypeofTypeAnnotation as TypeofTypeAnnotationType,
+  TypeOperator as TypeOperatorType,
   TypeParameter as TypeParameterType,
   TypeParameterDeclaration as TypeParameterDeclarationType,
   TypeParameterInstantiation as TypeParameterInstantiationType,
@@ -208,6 +210,11 @@ export type ArrayTypeAnnotationProps = {
   +elementType: MaybeDetachedNode<ArrayTypeAnnotationType['elementType']>,
 };
 
+export type AsExpressionProps = {
+  +expression: MaybeDetachedNode<AsExpressionType['expression']>,
+  +typeAnnotation: MaybeDetachedNode<AsExpressionType['typeAnnotation']>,
+};
+
 export type AssignmentExpressionProps = {
   +operator: AssignmentExpressionType['operator'],
   +left: MaybeDetachedNode<AssignmentExpressionType['left']>,
@@ -1019,6 +1026,11 @@ export type TypeofTypeAnnotationProps = {
   +argument: MaybeDetachedNode<TypeofTypeAnnotationType['argument']>,
 };
 
+export type TypeOperatorProps = {
+  +operator: TypeOperatorType['operator'],
+  +typeAnnotation: MaybeDetachedNode<TypeOperatorType['typeAnnotation']>,
+};
+
 export type TypeParameterProps = {
   +name: TypeParameterType['name'],
   +bound?: ?MaybeDetachedNode<TypeParameterType['bound']>,
@@ -1144,6 +1156,19 @@ export function ArrayTypeAnnotation(props: {
   return node;
 }
 
+export function AsExpression(props: {
+  ...$ReadOnly<AsExpressionProps>,
+  +parent?: ESNode,
+}): DetachedNode<AsExpressionType> {
+  const node = detachedProps<AsExpressionType>(props.parent, {
+    type: 'AsExpression',
+    expression: asDetachedNodeForCodeGen(props.expression),
+    typeAnnotation: asDetachedNodeForCodeGen(props.typeAnnotation),
+  });
+  setParentPointersInDirectChildren(node);
+  return node;
+}
+
 export function AssignmentExpression(props: {
   ...$ReadOnly<AssignmentExpressionProps>,
   +parent?: ESNode,
@@ -2951,6 +2976,19 @@ export function TypeofTypeAnnotation(props: {
   return node;
 }
 
+export function TypeOperator(props: {
+  ...$ReadOnly<TypeOperatorProps>,
+  +parent?: ESNode,
+}): DetachedNode<TypeOperatorType> {
+  const node = detachedProps<TypeOperatorType>(props.parent, {
+    type: 'TypeOperator',
+    operator: props.operator,
+    typeAnnotation: asDetachedNodeForCodeGen(props.typeAnnotation),
+  });
+  setParentPointersInDirectChildren(node);
+  return node;
+}
+
 export function TypeParameter(props: {
   ...$ReadOnly<TypeParameterProps>,
   +parent?: ESNode,

package/dist/generated/special-case-node-types/ExportNamedDeclaration.js

@@ -34,6 +34,7 @@ function ExportNamedDeclarationWithSpecifiers(props) {
     type: 'ExportNamedDeclaration',
     declaration: null,
     specifiers: props.specifiers.map(n => (0, _detachedNode.asDetachedNode)(n)),
+    // $FlowFixMe[incompatible-call]
     source: (0, _detachedNode.asDetachedNode)(props.source),
     exportKind: props.exportKind
   });

package/dist/generated/special-case-node-types/ExportNamedDeclaration.js.flow

@@ -66,6 +66,7 @@ export function ExportNamedDeclarationWithSpecifiers(props: {
       type: 'ExportNamedDeclaration',
       declaration: null,
       specifiers: props.specifiers.map(n => asDetachedNode(n)),
+      // $FlowFixMe[incompatible-call]
       source: asDetachedNode(props.source),
       exportKind: props.exportKind,
     },

package/dist/generated/special-case-node-types/ObjectTypeProperty.js

@@ -48,6 +48,7 @@ function ObjectTypePropertySignature(props) {
     proto: (_props$proto2 = props.proto) != null ? _props$proto2 : false,
     static: (_props$static2 = props.static) != null ? _props$static2 : false,
     value: (0, _detachedNode.asDetachedNode)(props.value),
+    // $FlowFixMe[incompatible-call]
     variance: (0, _detachedNode.asDetachedNode)(props.variance)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);

package/dist/generated/special-case-node-types/ObjectTypeProperty.js.flow

@@ -72,6 +72,7 @@ export function ObjectTypePropertySignature(props: {
     proto: props.proto ?? false,
     static: props.static ?? false,
     value: asDetachedNode(props.value),
+    // $FlowFixMe[incompatible-call]
     variance: asDetachedNode(props.variance),
   });
   setParentPointersInDirectChildren(node);

package/dist/generated/special-case-node-types/misc.js

@@ -30,8 +30,11 @@ function ArrowFunctionExpression(props) {
     expression: props.body.type !== 'BlockStatement',
     params: props.params.map(n => (0, _detachedNode.asDetachedNode)(n)),
     body: (0, _detachedNode.asDetachedNode)(props.body),
+    // $FlowFixMe[incompatible-call]
     typeParameters: (0, _detachedNode.asDetachedNode)(props.typeParameters),
+    // $FlowFixMe[incompatible-call]
     returnType: (0, _detachedNode.asDetachedNode)(props.returnType),
+    // $FlowFixMe[incompatible-call]
     predicate: (0, _detachedNode.asDetachedNode)(props.predicate),
     async: props.async
   });
@@ -44,9 +47,13 @@ function ClassDeclaration(props) {
 
   const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'ClassDeclaration',
+    // $FlowFixMe[incompatible-call]
     id: (0, _detachedNode.asDetachedNode)(props.id),
+    // $FlowFixMe[incompatible-call]
     typeParameters: (0, _detachedNode.asDetachedNode)(props.typeParameters),
+    // $FlowFixMe[incompatible-call]
     superClass: (0, _detachedNode.asDetachedNode)(props.superClass),
+    // $FlowFixMe[incompatible-call]
     superTypeParameters: (0, _detachedNode.asDetachedNode)(props.superTypeParameters),
     decorators: ((_props$decorators = props.decorators) != null ? _props$decorators : []).map(n => (0, _detachedNode.asDetachedNode)(n)),
     implements: ((_props$implements = props.implements) != null ? _props$implements : []).map(n => (0, _detachedNode.asDetachedNode)(n)),
@@ -77,6 +84,7 @@ function Identifier(props) {
     type: 'Identifier',
     name: props.name,
     optional: (_props$optional = props.optional) != null ? _props$optional : false,
+    // $FlowFixMe[incompatible-call]
     typeAnnotation: (0, _detachedNode.asDetachedNode)(props.typeAnnotation)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
@@ -113,6 +121,7 @@ function DeclareFunction(props) {
         typeAnnotation: (0, _detachedNode.asDetachedNode)(props.functionType)
       })
     }),
+    // $FlowFixMe[incompatible-call]
     predicate: (0, _detachedNode.asDetachedNode)(props.predicate)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);

package/dist/generated/special-case-node-types/misc.js.flow

@@ -63,8 +63,11 @@ export function ArrowFunctionExpression(props: {
     expression: props.body.type !== 'BlockStatement',
     params: props.params.map(n => asDetachedNode(n)),
     body: asDetachedNode(props.body),
+    // $FlowFixMe[incompatible-call]
     typeParameters: asDetachedNode(props.typeParameters),
+    // $FlowFixMe[incompatible-call]
     returnType: asDetachedNode(props.returnType),
+    // $FlowFixMe[incompatible-call]
     predicate: asDetachedNode(props.predicate),
     async: props.async,
   });
@@ -95,9 +98,13 @@ export function ClassDeclaration(props: {
 }): DetachedNode<ClassDeclarationType> {
   const node = detachedProps<ClassDeclarationType>(props.parent, {
     type: 'ClassDeclaration',
+    // $FlowFixMe[incompatible-call]
     id: asDetachedNode(props.id),
+    // $FlowFixMe[incompatible-call]
     typeParameters: asDetachedNode(props.typeParameters),
+    // $FlowFixMe[incompatible-call]
     superClass: asDetachedNode(props.superClass),
+    // $FlowFixMe[incompatible-call]
     superTypeParameters: asDetachedNode(props.superTypeParameters),
     decorators: (props.decorators ?? []).map(n => asDetachedNode(n)),
     implements: (props.implements ?? []).map(n => asDetachedNode(n)),
@@ -142,6 +149,7 @@ export function Identifier(props: {
     type: 'Identifier',
     name: props.name,
     optional: props.optional ?? false,
+    // $FlowFixMe[incompatible-call]
     typeAnnotation: asDetachedNode(props.typeAnnotation),
   });
   setParentPointersInDirectChildren(node);
@@ -199,6 +207,7 @@ export function DeclareFunction(props: {
         typeAnnotation: asDetachedNode(props.functionType),
       }),
     }),
+    // $FlowFixMe[incompatible-call]
     predicate: asDetachedNode(props.predicate),
   });
   setParentPointersInDirectChildren(node);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hermes-transform",
-  "version": "0.15.1",
+  "version": "0.17.0",
   "description": "Tools built on top of Hermes-ESTree to enable codebase transformation",
   "main": "dist/index.js",
   "license": "MIT",
@@ -12,13 +12,13 @@
     "@babel/code-frame": "^7.16.0",
     "esquery": "^1.4.0",
     "flow-enums-runtime": "^0.0.6",
-    "hermes-eslint": "0.15.1",
-    "hermes-estree": "0.15.1",
-    "hermes-parser": "0.15.1"
+    "hermes-eslint": "0.17.0",
+    "hermes-estree": "0.17.0",
+    "hermes-parser": "0.17.0"
   },
   "peerDependencies": {
     "prettier": "^3.0.0 || ^2.7.1",
-    "prettier-plugin-hermes-parser": "0.15.1"
+    "prettier-plugin-hermes-parser": "0.17.0"
   },
   "files": [
     "dist",