hermes-transform 0.8.0 → 0.9.0

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

@@ -7,6 +7,7 @@ exports.ArrowFunctionExpression = ArrowFunctionExpression;
 exports.BigIntLiteral = BigIntLiteral;
 exports.BlockComment = BlockComment;
 exports.BooleanLiteral = BooleanLiteral;
+exports.ClassDeclaration = ClassDeclaration;
 exports.Identifier = Identifier;
 exports.LineComment = LineComment;
 exports.NullLiteral = NullLiteral;
@@ -32,16 +33,35 @@ These are a number of special-case node creation functions that we can't auto-ge
 The list of exported functions here must be kept in sync with the `NODES_WITH_SPECIAL_HANDLING`
 list in `scripts/genTransformNodeTypes` to ensure there's no duplicates
 */
-function ArrowFunctionExpression({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function ArrowFunctionExpression(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'ArrowFunctionExpression',
     id: null,
     // $FlowExpectedError[incompatible-use]
     expression: props.body.type !== 'BlockStatement',
-    ...props
+    params: props.params.map(n => (0, _detachedNode.asDetachedNode)(n)),
+    body: (0, _detachedNode.asDetachedNode)(props.body),
+    typeParameters: (0, _detachedNode.asDetachedNode)(props.typeParameters),
+    returnType: (0, _detachedNode.asDetachedNode)(props.returnType),
+    predicate: (0, _detachedNode.asDetachedNode)(props.predicate),
+    async: props.async
+  });
+  (0, _detachedNode.setParentPointersInDirectChildren)(node);
+  return node;
+}
+
+function ClassDeclaration(props) {
+  var _props$decorators, _props$implements;
+
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
+    type: 'ClassDeclaration',
+    id: (0, _detachedNode.asDetachedNode)(props.id),
+    typeParameters: (0, _detachedNode.asDetachedNode)(props.typeParameters),
+    superClass: (0, _detachedNode.asDetachedNode)(props.superClass),
+    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)),
+    body: (0, _detachedNode.asDetachedNode)(props.body)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
@@ -49,49 +69,41 @@ function ArrowFunctionExpression({
 // also the value is supposed to be a RegExp instance
 
 
-function RegExpLiteral({
-  pattern,
-  flags,
-  parent
-}) {
-  const value = new RegExp(pattern, flags);
-  return (0, _detachedNode.detachedProps)(parent, {
+function RegExpLiteral(props) {
+  const value = new RegExp(props.pattern, props.flags);
+  return (0, _detachedNode.detachedProps)(props.parent, {
     type: 'Literal',
     value,
     raw: value.toString(),
     regex: {
-      pattern,
-      flags
+      pattern: props.pattern,
+      flags: props.flags
     }
   });
 } // raw/cooked are on a subobject in the estree spec, but are flat on the hermes types
 
 
-function TemplateElement({
-  tail,
-  parent,
-  ...value
-}) {
-  return (0, _detachedNode.detachedProps)(parent, {
+function TemplateElement(props) {
+  return (0, _detachedNode.detachedProps)(props.parent, {
     type: 'TemplateElement',
-    tail,
-    value
+    tail: props.tail,
+    value: {
+      cooked: props.cooked,
+      raw: props.raw
+    }
   });
 } // Identifier has a bunch of stuff that usually you don't want to provide - so we have
 // this manual def to allow us to default some values
 
 
-function Identifier({
-  parent,
-  optional = false,
-  typeAnnotation = null,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function Identifier(props) {
+  var _props$optional;
+
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'Identifier',
-    optional,
-    typeAnnotation,
-    ...props
+    name: props.name,
+    optional: (_props$optional = props.optional) != null ? _props$optional : false,
+    typeAnnotation: (0, _detachedNode.asDetachedNode)(props.typeAnnotation)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
@@ -100,15 +112,12 @@ function Identifier({
 //
 
 
-function BigIntLiteral({
-  parent,
-  ...props
-}) {
+function BigIntLiteral(props) {
   var _props$raw;
 
-  const node = (0, _detachedNode.detachedProps)(parent, {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'Literal',
-    ...props,
+    value: props.value,
     raw: (_props$raw = props.raw) != null ? _props$raw : `${props.value}n`,
     bigint: `${props.value}`
   });
@@ -116,84 +125,69 @@ function BigIntLiteral({
   return node;
 }
 
-function BooleanLiteral({
-  parent,
-  value
-}) {
-  return (0, _detachedNode.detachedProps)(parent, {
+function BooleanLiteral(props) {
+  return (0, _detachedNode.detachedProps)(props.parent, {
     type: 'Literal',
-    raw: value ? 'true' : 'false',
-    value
+    raw: props.value ? 'true' : 'false',
+    value: props.value
   });
 }
 
-function NumericLiteral({
-  parent,
-  ...props
-}) {
+function NumericLiteral(props) {
   var _props$raw2;
 
-  return (0, _detachedNode.detachedProps)(parent, {
+  return (0, _detachedNode.detachedProps)(props.parent, {
     type: 'Literal',
-    ...props,
+    value: props.value,
     raw: (_props$raw2 = props.raw) != null ? _props$raw2 : `${props.value}`
   });
 }
 
-function NullLiteral({
-  parent
-} = {}) {
-  return (0, _detachedNode.detachedProps)(parent, {
+function NullLiteral(props = { ...null
+}) {
+  return (0, _detachedNode.detachedProps)(props.parent, {
     type: 'Literal',
     value: null,
     raw: 'null'
   });
 }
 
-function StringLiteral({
-  parent,
-  raw: rawIn,
-  value
-}) {
-  const hasSingleQuote = value.includes('"');
-  const hasDoubleQuote = value.includes("'");
-  let raw = rawIn;
+function StringLiteral(props) {
+  const hasSingleQuote = props.value.includes('"');
+  const hasDoubleQuote = props.value.includes("'");
+  let raw = props.raw;
 
   if (raw == null) {
     if (hasSingleQuote && hasDoubleQuote) {
-      raw = `'${value.replace(/'/g, "\\'")}'`;
+      raw = `'${props.value.replace(/'/g, "\\'")}'`;
     } else if (hasSingleQuote) {
-      raw = `"${value}"`;
+      raw = `"${props.value}"`;
     } else {
-      raw = `'${value}'`;
+      raw = `'${props.value}'`;
     }
   }
 
-  return (0, _detachedNode.detachedProps)(parent, {
+  return (0, _detachedNode.detachedProps)(props.parent, {
     type: 'Literal',
     raw,
-    value
+    value: props.value
   });
 }
 
-function LineComment({
-  value
-}) {
+function LineComment(props) {
   // $FlowExpectedError[prop-missing]
   // $FlowExpectedError[incompatible-return]
   return (0, _detachedNode.detachedProps)(undefined, {
     type: 'Line',
-    value
+    value: props.value
   });
 }
 
-function BlockComment({
-  value
-}) {
+function BlockComment(props) {
   // $FlowExpectedError[prop-missing]
   // $FlowExpectedError[incompatible-return]
   return (0, _detachedNode.detachedProps)(undefined, {
     type: 'Block',
-    value
+    value: props.value
   });
 }

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

@@ -17,20 +17,22 @@ list in `scripts/genTransformNodeTypes` to ensure there's no duplicates
 import type {
   ESNode,
   ArrowFunctionExpression as ArrowFunctionExpressionType,
-  RegExpLiteral as RegExpLiteralType,
-  TemplateElement as TemplateElementType,
-  Identifier as IdentifierType,
   BigIntLiteral as BigIntLiteralType,
+  BlockComment as BlockCommentType,
   BooleanLiteral as BooleanLiteralType,
-  NumericLiteral as NumericLiteralType,
+  ClassDeclaration as ClassDeclarationType,
+  Identifier as IdentifierType,
+  LineComment as LineCommentType,
   NullLiteral as NullLiteralType,
+  NumericLiteral as NumericLiteralType,
+  RegExpLiteral as RegExpLiteralType,
   StringLiteral as StringLiteralType,
-  LineComment as LineCommentType,
-  BlockComment as BlockCommentType,
+  TemplateElement as TemplateElementType,
 } from 'hermes-estree';
-import type {DetachedNode} from '../detachedNode';
+import type {DetachedNode, MaybeDetachedNode} from '../detachedNode';
 
 import {
+  asDetachedNode,
   detachedProps,
   setParentPointersInDirectChildren,
 } from '../detachedNode';
@@ -40,29 +42,66 @@ import {
 // No need to make consumers set these
 export type ArrowFunctionExpressionProps = {
   +params: $ReadOnlyArray<
-    DetachedNode<ArrowFunctionExpressionType['params'][number]>,
+    MaybeDetachedNode<ArrowFunctionExpressionType['params'][number]>,
   >,
-  +body: DetachedNode<ArrowFunctionExpressionType['body']>,
-  +typeParameters?: ?DetachedNode<
+  +body: MaybeDetachedNode<ArrowFunctionExpressionType['body']>,
+  +typeParameters?: ?MaybeDetachedNode<
     ArrowFunctionExpressionType['typeParameters'],
   >,
-  +returnType?: ?DetachedNode<ArrowFunctionExpressionType['returnType']>,
-  +predicate?: ?DetachedNode<ArrowFunctionExpressionType['predicate']>,
+  +returnType?: ?MaybeDetachedNode<ArrowFunctionExpressionType['returnType']>,
+  +predicate?: ?MaybeDetachedNode<ArrowFunctionExpressionType['predicate']>,
   +async: ArrowFunctionExpressionType['async'],
 };
-export function ArrowFunctionExpression({
-  parent,
-  ...props
-}: {
+export function ArrowFunctionExpression(props: {
   ...$ReadOnly<ArrowFunctionExpressionProps>,
   +parent?: ESNode,
 }): DetachedNode<ArrowFunctionExpressionType> {
-  const node = detachedProps<ArrowFunctionExpressionType>(parent, {
+  const node = detachedProps<ArrowFunctionExpressionType>(props.parent, {
     type: 'ArrowFunctionExpression',
     id: null,
     // $FlowExpectedError[incompatible-use]
     expression: props.body.type !== 'BlockStatement',
-    ...props,
+    params: props.params.map(n => asDetachedNode(n)),
+    body: asDetachedNode(props.body),
+    typeParameters: asDetachedNode(props.typeParameters),
+    returnType: asDetachedNode(props.returnType),
+    predicate: asDetachedNode(props.predicate),
+    async: props.async,
+  });
+  setParentPointersInDirectChildren(node);
+  return node;
+}
+
+export type ClassDeclarationProps = {
+  +id?: ?MaybeDetachedNode<ClassDeclarationType['id']>,
+  +typeParameters?: ?MaybeDetachedNode<ClassDeclarationType['typeParameters']>,
+  +superClass?: ?MaybeDetachedNode<ClassDeclarationType['superClass']>,
+  +superTypeParameters?: ?MaybeDetachedNode<
+    ClassDeclarationType['superTypeParameters'],
+  >,
+  // make this optional as it's rarer that people would want to include them
+  +implements?: $ReadOnlyArray<
+    MaybeDetachedNode<ClassDeclarationType['implements'][number]>,
+  >,
+  // make this optional as it's rarer that people would want to include them
+  +decorators?: $ReadOnlyArray<
+    MaybeDetachedNode<ClassDeclarationType['decorators'][number]>,
+  >,
+  +body: MaybeDetachedNode<ClassDeclarationType['body']>,
+};
+export function ClassDeclaration(props: {
+  ...$ReadOnly<ClassDeclarationProps>,
+  +parent?: ESNode,
+}): DetachedNode<ClassDeclarationType> {
+  const node = detachedProps<ClassDeclarationType>(props.parent, {
+    type: 'ClassDeclaration',
+    id: asDetachedNode(props.id),
+    typeParameters: asDetachedNode(props.typeParameters),
+    superClass: asDetachedNode(props.superClass),
+    superTypeParameters: asDetachedNode(props.superTypeParameters),
+    decorators: (props.decorators ?? []).map(n => asDetachedNode(n)),
+    implements: (props.implements ?? []).map(n => asDetachedNode(n)),
+    body: asDetachedNode(props.body),
   });
   setParentPointersInDirectChildren(node);
   return node;
@@ -74,22 +113,18 @@ export type RegExpLiteralProps = {
   +pattern: RegExpLiteralType['regex']['pattern'],
   +flags: RegExpLiteralType['regex']['flags'],
 };
-export function RegExpLiteral({
-  pattern,
-  flags,
-  parent,
-}: {
+export function RegExpLiteral(props: {
   ...$ReadOnly<RegExpLiteralProps>,
   +parent?: ESNode,
 }): DetachedNode<RegExpLiteralType> {
-  const value = new RegExp(pattern, flags);
-  return detachedProps<RegExpLiteralType>(parent, {
+  const value = new RegExp(props.pattern, props.flags);
+  return detachedProps<RegExpLiteralType>(props.parent, {
     type: 'Literal',
     value,
     raw: value.toString(),
     regex: {
-      pattern,
-      flags,
+      pattern: props.pattern,
+      flags: props.flags,
     },
   });
 }
@@ -100,18 +135,17 @@ export type TemplateElementProps = {
   +cooked: TemplateElementType['value']['cooked'],
   +raw: TemplateElementType['value']['raw'],
 };
-export function TemplateElement({
-  tail,
-  parent,
-  ...value
-}: {
+export function TemplateElement(props: {
   ...$ReadOnly<TemplateElementProps>,
   +parent?: ESNode,
 }): DetachedNode<TemplateElementType> {
-  return detachedProps<TemplateElementType>(parent, {
+  return detachedProps<TemplateElementType>(props.parent, {
     type: 'TemplateElement',
-    tail,
-    value,
+    tail: props.tail,
+    value: {
+      cooked: props.cooked,
+      raw: props.raw,
+    },
   });
 }
 
@@ -119,23 +153,18 @@ export function TemplateElement({
 // this manual def to allow us to default some values
 export type IdentifierProps = {
   +name: IdentifierType['name'],
-  +typeAnnotation?: ?DetachedNode<IdentifierType['typeAnnotation']>,
+  +typeAnnotation?: ?MaybeDetachedNode<IdentifierType['typeAnnotation']>,
   +optional?: IdentifierType['optional'],
 };
-export function Identifier({
-  parent,
-  optional = false,
-  typeAnnotation = null,
-  ...props
-}: {
+export function Identifier(props: {
   ...$ReadOnly<IdentifierProps>,
   +parent?: ESNode,
 }): DetachedNode<IdentifierType> {
-  const node = detachedProps<IdentifierType>(parent, {
+  const node = detachedProps<IdentifierType>(props.parent, {
     type: 'Identifier',
-    optional,
-    typeAnnotation,
-    ...props,
+    name: props.name,
+    optional: props.optional ?? false,
+    typeAnnotation: asDetachedNode(props.typeAnnotation),
   });
   setParentPointersInDirectChildren(node);
   return node;
@@ -153,16 +182,13 @@ export type BigIntLiteralProps = {
    */
   +raw?: NumericLiteralType['raw'],
 };
-export function BigIntLiteral({
-  parent,
-  ...props
-}: {
+export function BigIntLiteral(props: {
   ...$ReadOnly<BigIntLiteralProps>,
   +parent?: ESNode,
 }): DetachedNode<BigIntLiteralType> {
-  const node = detachedProps<BigIntLiteralType>(parent, {
+  const node = detachedProps<BigIntLiteralType>(props.parent, {
     type: 'Literal',
-    ...props,
+    value: props.value,
     raw: props.raw ?? `${props.value}n`,
     bigint: `${props.value}`,
   });
@@ -173,17 +199,14 @@ export function BigIntLiteral({
 export type BooleanLiteralProps = {
   +value: BooleanLiteralType['value'],
 };
-export function BooleanLiteral({
-  parent,
-  value,
-}: {
+export function BooleanLiteral(props: {
   ...$ReadOnly<BooleanLiteralProps>,
   +parent?: ESNode,
 }): DetachedNode<BooleanLiteralType> {
-  return detachedProps<BooleanLiteralType>(parent, {
+  return detachedProps<BooleanLiteralType>(props.parent, {
     type: 'Literal',
-    raw: value ? 'true' : 'false',
-    value,
+    raw: props.value ? 'true' : 'false',
+    value: props.value,
   });
 }
 
@@ -195,27 +218,24 @@ export type NumericLiteralProps = {
    */
   +raw?: NumericLiteralType['raw'],
 };
-export function NumericLiteral({
-  parent,
-  ...props
-}: {
+export function NumericLiteral(props: {
   ...$ReadOnly<NumericLiteralProps>,
   +parent?: ESNode,
 }): DetachedNode<NumericLiteralType> {
-  return detachedProps<NumericLiteralType>(parent, {
+  return detachedProps<NumericLiteralType>(props.parent, {
     type: 'Literal',
-    ...props,
+    value: props.value,
     raw: props.raw ?? `${props.value}`,
   });
 }
 
 export type NullLiteralProps = {};
-export function NullLiteral({
-  parent,
-}: {
-  +parent?: ESNode,
-} = {}): DetachedNode<NullLiteralType> {
-  return detachedProps<NullLiteralType>(parent, {
+export function NullLiteral(
+  props: {
+    +parent?: ESNode,
+  } = {...null},
+): DetachedNode<NullLiteralType> {
+  return detachedProps<NullLiteralType>(props.parent, {
     type: 'Literal',
     value: null,
     raw: 'null',
@@ -226,49 +246,45 @@ export type StringLiteralProps = {
   +value: StringLiteralType['value'],
   +raw?: StringLiteralType['raw'],
 };
-export function StringLiteral({
-  parent,
-  raw: rawIn,
-  value,
-}: {
+export function StringLiteral(props: {
   ...$ReadOnly<StringLiteralProps>,
   +parent?: ESNode,
 }): DetachedNode<StringLiteralType> {
-  const hasSingleQuote = value.includes('"');
-  const hasDoubleQuote = value.includes("'");
-  let raw = rawIn;
+  const hasSingleQuote = props.value.includes('"');
+  const hasDoubleQuote = props.value.includes("'");
+  let raw = props.raw;
   if (raw == null) {
     if (hasSingleQuote && hasDoubleQuote) {
-      raw = `'${value.replace(/'/g, "\\'")}'`;
+      raw = `'${props.value.replace(/'/g, "\\'")}'`;
     } else if (hasSingleQuote) {
-      raw = `"${value}"`;
+      raw = `"${props.value}"`;
     } else {
-      raw = `'${value}'`;
+      raw = `'${props.value}'`;
     }
   }
-  return detachedProps<StringLiteralType>(parent, {
+  return detachedProps<StringLiteralType>(props.parent, {
     type: 'Literal',
     raw,
-    value,
+    value: props.value,
   });
 }
 
 export type LineCommentProps = {+value: string};
-export function LineComment({value}: LineCommentProps): LineCommentType {
+export function LineComment(props: LineCommentProps): LineCommentType {
   // $FlowExpectedError[prop-missing]
   // $FlowExpectedError[incompatible-return]
   return detachedProps<LineCommentType>(undefined, {
     type: 'Line',
-    value,
+    value: props.value,
   });
 }
 
 export type BlockCommentProps = {+value: string};
-export function BlockComment({value}: BlockCommentProps): BlockCommentType {
+export function BlockComment(props: BlockCommentProps): BlockCommentType {
   // $FlowExpectedError[prop-missing]
   // $FlowExpectedError[incompatible-return]
   return detachedProps<BlockCommentType>(undefined, {
     type: 'Block',
-    value,
+    value: props.value,
   });
 }

package/dist/transform/TransformContext.js

@@ -52,10 +52,9 @@ function getTransformContext() {
         return null;
       }
 
-      return (0, _detachedNode.shallowCloneNode)(node);
+      return (0, _detachedNode.shallowCloneNode)(node, {});
     },
-    // $FlowExpectedError[incompatible-exact]
-    shallowCloneNodeWithOverrides: (node, newProps) => {
+    shallowCloneNodeWithOverrides: (node, newProps = {}) => {
       if (node == null) {
         return null;
       }
@@ -67,17 +66,23 @@ function getTransformContext() {
         return null;
       }
 
-      return nodes.map(node => (0, _detachedNode.shallowCloneNode)(node));
+      return nodes.map(node => {
+        if (node == null) {
+          // $FlowExpectedError[incompatible-call]
+          return node;
+        }
+
+        return (0, _detachedNode.shallowCloneNode)(node, {});
+      });
     },
     deepCloneNode: node => {
       if (node == null) {
         return null;
       }
 
-      return (0, _detachedNode.deepCloneNode)(node);
+      return (0, _detachedNode.deepCloneNode)(node, {});
     },
-    // $FlowExpectedError[incompatible-exact]
-    deepCloneNodeWithOverrides: (node, newProps) => {
+    deepCloneNodeWithOverrides: (node, newProps = {}) => {
       if (node == null) {
         return null;
       }
@@ -130,10 +135,14 @@ function getTransformContext() {
   };
   const insertAPIs = {
     insertAfterStatement: (target, nodesToInsert) => {
-      pushMutation((0, _InsertStatement.createInsertStatementMutation)('after', target, toArray(nodesToInsert)));
+      pushMutation((0, _InsertStatement.createInsertStatementMutation)('after', target, toArray(nodesToInsert).map(n => (0, _detachedNode.asDetachedNode)(n, {
+        useDeepClone: true
+      }))));
     },
     insertBeforeStatement: (target, nodesToInsert) => {
-      pushMutation((0, _InsertStatement.createInsertStatementMutation)('before', target, toArray(nodesToInsert)));
+      pushMutation((0, _InsertStatement.createInsertStatementMutation)('before', target, toArray(nodesToInsert).map(n => (0, _detachedNode.asDetachedNode)(n, {
+        useDeepClone: true
+      }))));
     }
   };
   const removeAPIs = {
@@ -146,10 +155,23 @@ function getTransformContext() {
   };
   const replaceAPIs = {
     replaceNode: (target, nodeToReplaceWith, options) => {
-      pushMutation((0, _ReplaceNode.createReplaceNodeMutation)(target, nodeToReplaceWith, options));
+      pushMutation((0, _ReplaceNode.createReplaceNodeMutation)(target, (0, _detachedNode.asDetachedNode)(nodeToReplaceWith), options));
     },
     replaceStatementWithMany: (target, nodesToReplaceWith, options) => {
-      pushMutation((0, _ReplaceStatementWithMany.createReplaceStatementWithManyMutation)(target, nodesToReplaceWith, options));
+      pushMutation((0, _ReplaceStatementWithMany.createReplaceStatementWithManyMutation)(target, nodesToReplaceWith.map(n => (0, _detachedNode.asDetachedNode)(n)), options));
+    }
+  };
+  const modifyAPIs = {
+    modifyNodeInPlace: (node, newProps = {}, options) => {
+      if (node == null) {
+        return;
+      }
+
+      const cloned = (0, _detachedNode.shallowCloneNode)(node, newProps, {
+        preserveLocation: true
+      }); // $FlowExpectedError[incompatible-call]
+
+      replaceAPIs.replaceNode(node, cloned, options);
     }
   };
   return {
@@ -163,6 +185,7 @@ function getTransformContext() {
     ...cloneAPIs,
     ...commentAPIs,
     ...insertAPIs,
+    ...modifyAPIs,
     ...removeAPIs,
     ...replaceAPIs
   };