hermes-transform 0.16.0 → 0.17.0

package/dist/generated/TransformCloneSignatures.js.flow

@@ -27,6 +27,7 @@ import type {
   ArrayPattern,
   ArrayTypeAnnotation,
   ArrowFunctionExpression,
+  AsExpression,
   AssignmentExpression,
   AssignmentPattern,
   AwaitExpression,
@@ -201,6 +202,7 @@ import type {
   ArrayPatternProps,
   ArrayTypeAnnotationProps,
   ArrowFunctionExpressionProps,
+  AsExpressionProps,
   AssignmentExpressionProps,
   AssignmentPatternProps,
   AwaitExpressionProps,
@@ -411,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>,
@@ -1749,6 +1759,7 @@ export type TransformCloneSignatures = AnyTypeAnnotationCloneSignature &
   ArrayPatternCloneSignature &
   ArrayTypeAnnotationCloneSignature &
   ArrowFunctionExpressionCloneSignature &
+  AsExpressionCloneSignature &
   AssignmentExpressionCloneSignature &
   AssignmentPatternCloneSignature &
   AwaitExpressionCloneSignature &

package/dist/generated/TransformModifySignatures.js.flow

@@ -27,6 +27,7 @@ import type {
   ArrayPattern,
   ArrayTypeAnnotation,
   ArrowFunctionExpression,
+  AsExpression,
   AssignmentExpression,
   AssignmentPattern,
   AwaitExpression,
@@ -201,6 +202,7 @@ import type {
   ArrayPatternProps,
   ArrayTypeAnnotationProps,
   ArrowFunctionExpressionProps,
+  AsExpressionProps,
   AssignmentExpressionProps,
   AssignmentPatternProps,
   AwaitExpressionProps,
@@ -390,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>,
@@ -1063,6 +1069,7 @@ export type TransformModifySignatures = AnyTypeAnnotationModifySignature &
   ArrayPatternModifySignature &
   ArrayTypeAnnotationModifySignature &
   ArrowFunctionExpressionModifySignature &
+  AsExpressionModifySignature &
   AssignmentExpressionModifySignature &
   AssignmentPatternModifySignature &
   AwaitExpressionModifySignature &

package/dist/generated/TransformReplaceSignatures.js.flow

@@ -27,6 +27,7 @@ import type {
   ArrayPattern,
   ArrayTypeAnnotation,
   ArrowFunctionExpression,
+  AsExpression,
   AssignmentExpression,
   AssignmentPattern,
   AwaitExpression,
@@ -218,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>,
@@ -1038,6 +1044,7 @@ export type TransformReplaceSignatures = AnyTypeAnnotationReplaceSignature &
   ArrayPatternReplaceSignature &
   ArrayTypeAnnotationReplaceSignature &
   ArrowFunctionExpressionReplaceSignature &
+  AsExpressionReplaceSignature &
   AssignmentExpressionReplaceSignature &
   AssignmentPatternReplaceSignature &
   AwaitExpressionReplaceSignature &

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,
@@ -187,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;
@@ -388,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',

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,
@@ -209,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']>,
@@ -1150,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,

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.16.0",
+  "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.16.0",
-    "hermes-estree": "0.16.0",
-    "hermes-parser": "0.16.0"
+    "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.16.0"
+    "prettier-plugin-hermes-parser": "0.17.0"
   },
   "files": [
     "dist",