hermes-transform 0.22.0 → 0.23.1

package/dist/generated/TransformCloneSignatures.js.flow

@@ -157,6 +157,7 @@ import type {
   OpaqueType,
   OptionalIndexedAccessType,
   PrivateIdentifier,
+  Program,
   Property,
   PropertyDefinition,
   QualifiedTypeIdentifier,
@@ -339,6 +340,7 @@ import type {
   OpaqueTypeProps,
   OptionalIndexedAccessTypeProps,
   PrivateIdentifierProps,
+  ProgramProps,
   PropertyProps,
   PropertyDefinitionProps,
   QualifiedTypeIdentifierProps,
@@ -1467,6 +1469,14 @@ type PrivateIdentifierCloneSignature = ((
     node: ?PrivateIdentifier,
     newProps: Partial<PrivateIdentifierProps>,
   ) => DetachedNode<PrivateIdentifier> | null);
+type ProgramCloneSignature = ((
+  node: Program,
+  newProps: Partial<ProgramProps>,
+) => DetachedNode<Program>) &
+  ((
+    node: ?Program,
+    newProps: Partial<ProgramProps>,
+  ) => DetachedNode<Program> | null);
 type PropertyCloneSignature = ((
   node: Property,
   newProps: Partial<PropertyProps>,
@@ -1959,6 +1969,7 @@ export type TransformCloneSignatures = AnyTypeAnnotationCloneSignature &
   OpaqueTypeCloneSignature &
   OptionalIndexedAccessTypeCloneSignature &
   PrivateIdentifierCloneSignature &
+  ProgramCloneSignature &
   PropertyCloneSignature &
   PropertyDefinitionCloneSignature &
   QualifiedTypeIdentifierCloneSignature &

package/dist/generated/TransformModifySignatures.js.flow

@@ -157,6 +157,7 @@ import type {
   OpaqueType,
   OptionalIndexedAccessType,
   PrivateIdentifier,
+  Program,
   Property,
   PropertyDefinition,
   QualifiedTypeIdentifier,
@@ -339,6 +340,7 @@ import type {
   OpaqueTypeProps,
   OptionalIndexedAccessTypeProps,
   PrivateIdentifierProps,
+  ProgramProps,
   PropertyProps,
   PropertyDefinitionProps,
   QualifiedTypeIdentifierProps,
@@ -926,6 +928,10 @@ type PrivateIdentifierModifySignature = (
   node: ?PrivateIdentifier,
   newProps: Partial<PrivateIdentifierProps>,
 ) => void;
+type ProgramModifySignature = (
+  node: ?Program,
+  newProps: Partial<ProgramProps>,
+) => void;
 type PropertyModifySignature = (
   node: ?Property,
   newProps: Partial<PropertyProps>,
@@ -1241,6 +1247,7 @@ export type TransformModifySignatures = AnyTypeAnnotationModifySignature &
   OpaqueTypeModifySignature &
   OptionalIndexedAccessTypeModifySignature &
   PrivateIdentifierModifySignature &
+  ProgramModifySignature &
   PropertyModifySignature &
   PropertyDefinitionModifySignature &
   QualifiedTypeIdentifierModifySignature &

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

@@ -89,15 +89,19 @@ function Identifier(props) {
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
-}
+} // Program 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 Program(props) {
+  var _props$sourceType, _props$tokens, _props$comments;
+
   return (0, _detachedNode.detachedProps)(null, {
     type: 'Program',
-    sourceType: props.sourceType,
+    sourceType: (_props$sourceType = props.sourceType) != null ? _props$sourceType : 'module',
     body: props.body.map(n => (0, _detachedNode.asDetachedNode)(n)),
-    tokens: props.tokens,
-    comments: props.comments,
+    tokens: (_props$tokens = props.tokens) != null ? _props$tokens : [],
+    comments: (_props$comments = props.comments) != null ? _props$comments : [],
     interpreter: props.interpreter != null ? // $FlowFixMe[incompatible-call]
     (0, _detachedNode.asDetachedNode)({
       type: 'InterpreterDirective',

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

@@ -156,23 +156,25 @@ export function Identifier(props: {
   return node;
 }
 
+// Program 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
 export type ProgramProps = {
-  +sourceType: ProgramType['sourceType'],
+  +sourceType?: ?ProgramType['sourceType'],
   +body: $ReadOnlyArray<MaybeDetachedNode<ProgramType['body'][number]>>,
-  +tokens: $ReadOnlyArray<MaybeDetachedNode<TokenType>>,
-  +comments: $ReadOnlyArray<MaybeDetachedNode<CommentType>>,
-  +interpreter: null | string,
-  +docblock: null | DocblockMetadataType,
+  +tokens?: ?$ReadOnlyArray<MaybeDetachedNode<TokenType>>,
+  +comments?: ?$ReadOnlyArray<MaybeDetachedNode<CommentType>>,
+  +interpreter?: ?string,
+  +docblock?: ?DocblockMetadataType,
 };
 export function Program(props: {
   ...$ReadOnly<ProgramProps>,
 }): DetachedNode<ProgramType> {
   return detachedProps<ProgramType>(null, {
     type: 'Program',
-    sourceType: props.sourceType,
+    sourceType: props.sourceType ?? 'module',
     body: props.body.map(n => asDetachedNode(n)),
-    tokens: props.tokens,
-    comments: props.comments,
+    tokens: props.tokens ?? [],
+    comments: props.comments ?? [],
     interpreter:
       props.interpreter != null
         ? // $FlowFixMe[incompatible-call]

package/dist/transform/TransformContext.js

@@ -7,6 +7,8 @@ exports.getTransformContext = getTransformContext;
 
 var _detachedNode = require("../detachedNode");
 
+var _hermesParser = require("hermes-parser");
+
 var _comments = require("./comments/comments");
 
 var _AddComments = require("./mutations/AddComments");
@@ -25,6 +27,8 @@ var _ReplaceNode = require("./mutations/ReplaceNode");
 
 var _ReplaceStatementWithMany = require("./mutations/ReplaceStatementWithMany");
 
+var _ModifyNodeInPlace = require("./mutations/ModifyNodeInPlace");
+
 /**
  * Copyright (c) Meta Platforms, Inc. and affiliates.
  *
@@ -167,15 +171,20 @@ function getTransformContext() {
     }
   };
   const modifyAPIs = {
-    modifyNodeInPlace: (node, newProps = {}, options) => {
-      if (node == null) {
-        return;
+    modifyNodeInPlace: (target, newProps) => {
+      const detachedProps = {};
+
+      for (const [key, value] of Object.entries(newProps)) {
+        if ((0, _hermesParser.isNode)(value)) {
+          // $FlowFixMe[incompatible-type]
+          const node = value;
+          detachedProps[key] = (0, _detachedNode.asDetachedNode)(node);
+        } else {
+          detachedProps[key] = value;
+        }
       }
 
-      const cloned = (0, _detachedNode.shallowCloneNode)(node, newProps, {
-        preserveLocation: true
-      });
-      replaceAPIs.replaceNode(node, cloned, options);
+      pushMutation((0, _ModifyNodeInPlace.createModifyNodeInPlaceMutation)(target, detachedProps));
     }
   };
   return {

package/dist/transform/TransformContext.js.flow

@@ -30,12 +30,14 @@ import type {RemoveCommentMutation} from './mutations/RemoveComment';
 import type {RemoveNodeMutation} from './mutations/RemoveNode';
 import type {RemoveStatementMutation} from './mutations/RemoveStatement';
 import type {ReplaceNodeMutation} from './mutations/ReplaceNode';
+import type {ModifyNodeInPlaceMutation} from './mutations/ModifyNodeInPlace';
 import type {
   ReplaceStatementWithManyMutation,
   ReplaceStatementWithManyMutationNodes,
 } from './mutations/ReplaceStatementWithMany';
 
 import {asDetachedNode, deepCloneNode, shallowCloneNode} from '../detachedNode';
+import {isNode} from 'hermes-parser';
 import {
   CommentPlacement,
   getCommentsForNode,
@@ -50,6 +52,7 @@ import {createRemoveNodeMutation} from './mutations/RemoveNode';
 import {createRemoveStatementMutation} from './mutations/RemoveStatement';
 import {createReplaceNodeMutation} from './mutations/ReplaceNode';
 import {createReplaceStatementWithManyMutation} from './mutations/ReplaceStatementWithMany';
+import {createModifyNodeInPlaceMutation} from './mutations/ModifyNodeInPlace';
 
 type Mutation = $ReadOnly<
   | AddCommentsMutation
@@ -59,7 +62,8 @@ type Mutation = $ReadOnly<
   | RemoveNodeMutation
   | RemoveStatementMutation
   | ReplaceNodeMutation
-  | ReplaceStatementWithManyMutation,
+  | ReplaceStatementWithManyMutation
+  | ModifyNodeInPlaceMutation,
 >;
 
 type SingleOrArray<+T> = T | $ReadOnlyArray<T>;
@@ -525,21 +529,19 @@ export function getTransformContext(): TransformContextAdditions {
     }: TransformReplaceAPIs['replaceStatementWithMany']),
   };
   const modifyAPIs: TransformModifyAPIs = {
-    modifyNodeInPlace: ((
-      node: ?ESNode,
-      newProps?: $ReadOnly<{...}> = {},
-      options?: ReplaceNodeOptions,
-    ): void => {
-      if (node == null) {
-        return;
+    modifyNodeInPlace: ((target: ESNode, newProps: $ReadOnly<{...}>): void => {
+      const detachedProps = {};
+      for (const [key, value] of Object.entries(newProps)) {
+        if (isNode(value)) {
+          // $FlowFixMe[incompatible-type]
+          const node: ESNode = value;
+          detachedProps[key] = asDetachedNode(node);
+        } else {
+          detachedProps[key] = value;
+        }
       }
 
-      const cloned = shallowCloneNode(node, newProps, {preserveLocation: true});
-      replaceAPIs.replaceNode(
-        (node: $FlowFixMe),
-        (cloned: $FlowFixMe),
-        options,
-      );
+      pushMutation(createModifyNodeInPlaceMutation(target, detachedProps));
     }: TransformModifyAPIs['modifyNodeInPlace']),
   };
 

package/dist/transform/comments/comments.js

@@ -5,19 +5,21 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.CommentPlacement = void 0;
 exports.addComment = addComment;
-exports.addCommentsToNode = addCommentsToNode;
 exports.appendCommentToSource = appendCommentToSource;
 exports.attachComments = attachComments;
 exports.cloneComment = cloneComment;
 exports.cloneCommentWithMarkers = cloneCommentWithMarkers;
+exports.cloneCommentsToNewNode = cloneCommentsToNewNode;
 exports.cloneJSDocCommentsToNewNode = cloneJSDocCommentsToNewNode;
 exports.getCommentsForNode = getCommentsForNode;
 exports.getLeadingCommentsForNode = getLeadingCommentsForNode;
 exports.getTrailingCommentsForNode = getTrailingCommentsForNode;
+exports.isAttachedComment = isAttachedComment;
 exports.isLeadingComment = isLeadingComment;
 exports.isTrailingComment = isTrailingComment;
 exports.makeCommentOwnLine = makeCommentOwnLine;
 exports.moveCommentsToNewNode = moveCommentsToNewNode;
+exports.mutateESTreeASTCommentsForPrettier = mutateESTreeASTCommentsForPrettier;
 exports.setCommentsOnNode = setCommentsOnNode;
 
 var _comments = require("./prettier/main/comments");
@@ -58,11 +60,65 @@ function attachComments(comments, ast, text) {
   });
 }
 
+function mutateESTreeASTCommentsForPrettier(program, text) {
+  let code = text; // we need to delete the comments prop or else prettier will do
+  // its own attachment pass after the mutation and duplicate the
+  // comments on each node, borking the output
+  // $FlowExpectedError[cannot-write]
+
+  delete program.comments; // The docblock comment is never attached to any AST nodes, since its technically
+  // attached to the program. However this is specific to our AST and in order for
+  // prettier to correctly print it we need to attach it to the first node in the
+  // program body.
+
+  if (program.docblock != null && program.docblock.comment != null) {
+    const docblockComment = program.docblock.comment;
+    const isDocblockCommentNew = !isAttachedComment(docblockComment);
+
+    if (isDocblockCommentNew) {
+      // $FlowExpectedError[prop-missing]
+      docblockComment.printed = false; // $FlowExpectedError[prop-missing]
+
+      docblockComment.leading = true; // $FlowExpectedError[prop-missing]
+
+      docblockComment.trailing = false;
+    } // If we have a first node in the program body, attache the comment to that
+    // otherwise set it on the program.
+
+
+    if (program.body.length > 0) {
+      const firstStatement = program.body[0];
+      const leadingComments = getLeadingCommentsForNode(firstStatement);
+
+      if (!leadingComments.includes(docblockComment)) {
+        setCommentsOnNode(firstStatement, [docblockComment, ...getCommentsForNode(firstStatement)]);
+
+        if (isDocblockCommentNew) {
+          // Add markers to the code block to ensure docblock comment is printed on its
+          // own line.
+          code = makeCommentOwnLine(code, docblockComment);
+        }
+      }
+    } else {
+      setCommentsOnNode(program, [docblockComment]);
+    }
+  } // Should not be needed anymore
+  // $FlowExpectedError[cannot-write]
+
+
+  delete program.docblock;
+  return code;
+}
+
 function moveCommentsToNewNode(oldNode, newNode) {
   setCommentsOnNode(newNode, getCommentsForNode(oldNode));
   setCommentsOnNode(oldNode, []);
 }
 
+function cloneCommentsToNewNode(oldNode, newNode) {
+  setCommentsOnNode(newNode, getCommentsForNode(oldNode).map(comment => cloneCommentWithMarkers(comment)));
+}
+
 function cloneJSDocCommentsToNewNode(oldNode, newNode) {
   const comments = getCommentsForNode(oldNode).filter(comment => {
     return (0, _hermesEstree.isBlockComment)(comment) && // JSDoc comments always start with an extra asterisk
@@ -76,28 +132,17 @@ function setCommentsOnNode(node, comments) {
   node.comments = comments;
 }
 
-function addCommentsToNode(node, comments, side = 'trailing') {
+function getCommentsForNode(node) {
   var _node$comments;
 
-  // $FlowExpectedError[prop-missing] - this property is secretly added by prettier.
-  // $FlowExpectedError[cannot-write]
-  // $FlowExpectedError[incompatible-use]
-  node.comments = (_node$comments = node.comments) != null ? _node$comments : [];
-
-  if (side === 'leading') {
-    // $FlowExpectedError[incompatible-cast]
-    node.comments.unshift(...comments);
-  } else {
-    // $FlowExpectedError[incompatible-cast]
-    node.comments.push(...comments);
-  }
+  // $FlowExpectedError - this property is secretly added by prettier.
+  return (_node$comments = node.comments) != null ? _node$comments : [];
 }
 
-function getCommentsForNode(node) {
-  var _node$comments2;
-
-  // $FlowExpectedError - this property is secretly added by prettier.
-  return (_node$comments2 = node.comments) != null ? _node$comments2 : [];
+function isAttachedComment(comment) {
+  // Prettier adds this property to comments that have been attached.
+  // $FlowExpectedError[prop-missing] - this property is secretly added by prettier.
+  return comment.printed === false;
 }
 
 function isLeadingComment(comment) {

package/dist/transform/comments/comments.js.flow

@@ -22,6 +22,7 @@ import {
   addLeadingComment as untypedAddLeadingComment,
   // $FlowExpectedError[untyped-import]
   addTrailingComment as untypedAddTrailingComment,
+  // $FlowFixMe[untyped-import]
 } from './prettier/common/util';
 import {isBlockComment} from 'hermes-estree';
 import {EOL} from 'os';
@@ -47,6 +48,64 @@ export function attachComments(
   });
 }
 
+export function mutateESTreeASTCommentsForPrettier(
+  program: Program,
+  text: string,
+): string {
+  let code = text;
+
+  // we need to delete the comments prop or else prettier will do
+  // its own attachment pass after the mutation and duplicate the
+  // comments on each node, borking the output
+  // $FlowExpectedError[cannot-write]
+  delete program.comments;
+
+  // The docblock comment is never attached to any AST nodes, since its technically
+  // attached to the program. However this is specific to our AST and in order for
+  // prettier to correctly print it we need to attach it to the first node in the
+  // program body.
+  if (program.docblock != null && program.docblock.comment != null) {
+    const docblockComment = program.docblock.comment;
+
+    const isDocblockCommentNew = !isAttachedComment(docblockComment);
+    if (isDocblockCommentNew) {
+      // $FlowExpectedError[prop-missing]
+      docblockComment.printed = false;
+      // $FlowExpectedError[prop-missing]
+      docblockComment.leading = true;
+      // $FlowExpectedError[prop-missing]
+      docblockComment.trailing = false;
+    }
+
+    // If we have a first node in the program body, attache the comment to that
+    // otherwise set it on the program.
+    if (program.body.length > 0) {
+      const firstStatement = program.body[0];
+      const leadingComments = getLeadingCommentsForNode(firstStatement);
+      if (!leadingComments.includes(docblockComment)) {
+        setCommentsOnNode(firstStatement, [
+          docblockComment,
+          ...getCommentsForNode(firstStatement),
+        ]);
+
+        if (isDocblockCommentNew) {
+          // Add markers to the code block to ensure docblock comment is printed on its
+          // own line.
+          code = makeCommentOwnLine(code, docblockComment);
+        }
+      }
+    } else {
+      setCommentsOnNode(program, [docblockComment]);
+    }
+  }
+
+  // Should not be needed anymore
+  // $FlowExpectedError[cannot-write]
+  delete program.docblock;
+
+  return code;
+}
+
 export function moveCommentsToNewNode(
   oldNode: ESNode,
   newNode: DetachedNode<ESNode>,
@@ -55,6 +114,18 @@ export function moveCommentsToNewNode(
   setCommentsOnNode(oldNode, []);
 }
 
+export function cloneCommentsToNewNode(
+  oldNode: MaybeDetachedNode<ESNode>,
+  newNode: MaybeDetachedNode<ESNode>,
+): void {
+  setCommentsOnNode(
+    newNode,
+    getCommentsForNode(oldNode).map(comment =>
+      cloneCommentWithMarkers(comment),
+    ),
+  );
+}
+
 export function cloneJSDocCommentsToNewNode(
   oldNode: ESNode,
   newNode: MaybeDetachedNode<ESNode>,
@@ -80,24 +151,6 @@ export function setCommentsOnNode(
   node.comments = comments;
 }
 
-export function addCommentsToNode(
-  node: ESNode | DetachedNode<ESNode>,
-  comments: $ReadOnlyArray<Comment>,
-  side?: 'leading' | 'trailing' = 'trailing',
-): void {
-  // $FlowExpectedError[prop-missing] - this property is secretly added by prettier.
-  // $FlowExpectedError[cannot-write]
-  // $FlowExpectedError[incompatible-use]
-  node.comments = node.comments ?? [];
-  if (side === 'leading') {
-    // $FlowExpectedError[incompatible-cast]
-    (node.comments: Array<Comment>).unshift(...comments);
-  } else {
-    // $FlowExpectedError[incompatible-cast]
-    (node.comments: Array<Comment>).push(...comments);
-  }
-}
-
 export function getCommentsForNode(
   node: ESNode | DetachedNode<ESNode>,
 ): $ReadOnlyArray<Comment> {
@@ -105,6 +158,12 @@ export function getCommentsForNode(
   return node.comments ?? [];
 }
 
+export function isAttachedComment(comment: Comment): boolean {
+  // Prettier adds this property to comments that have been attached.
+  // $FlowExpectedError[prop-missing] - this property is secretly added by prettier.
+  return comment.printed === false;
+}
+
 export function isLeadingComment(comment: Comment): boolean {
   // $FlowExpectedError - this property is secretly added by prettier.
   return comment.leading === true;

package/dist/transform/mutations/CloneCommentsTo.js

@@ -26,13 +26,6 @@ function createCloneCommentsToMutation(target, destination) {
 }
 
 function performCloneCommentsToMutation(_mutationContext, mutation) {
-  const newComments = [];
-
-  for (const originalComment of (0, _comments.getCommentsForNode)(mutation.target)) {
-    const comment = (0, _comments.cloneCommentWithMarkers)(originalComment);
-    newComments.push(comment);
-  }
-
-  (0, _comments.addCommentsToNode)(mutation.destination, newComments);
+  (0, _comments.cloneCommentsToNewNode)(mutation.target, mutation.destination);
   return null;
 }

package/dist/transform/mutations/CloneCommentsTo.js.flow

@@ -12,11 +12,7 @@ import type {ESNode} from 'hermes-estree';
 import type {DetachedNode} from '../../detachedNode';
 import type {MutationContext} from '../MutationContext';
 
-import {
-  addCommentsToNode,
-  cloneCommentWithMarkers,
-  getCommentsForNode,
-} from '../comments/comments';
+import {cloneCommentsToNewNode} from '../comments/comments';
 
 export type CloneCommentsToMutation = $ReadOnly<{
   type: 'cloneCommentsTo',
@@ -39,12 +35,6 @@ export function performCloneCommentsToMutation(
   _mutationContext: MutationContext,
   mutation: CloneCommentsToMutation,
 ): null {
-  const newComments = [];
-  for (const originalComment of getCommentsForNode(mutation.target)) {
-    const comment = cloneCommentWithMarkers(originalComment);
-    newComments.push(comment);
-  }
-  addCommentsToNode(mutation.destination, newComments);
-
+  cloneCommentsToNewNode(mutation.target, mutation.destination);
   return null;
 }

package/dist/transform/mutations/ModifyNodeInPlace.js

@@ -0,0 +1,59 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createModifyNodeInPlaceMutation = createModifyNodeInPlaceMutation;
+exports.performModifyNodeInPlaceMutation = performModifyNodeInPlaceMutation;
+
+var _hermesParser = require("hermes-parser");
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ * @format
+ */
+function createModifyNodeInPlaceMutation(target, newProps) {
+  return {
+    type: 'modifyNodeInPlace',
+    target,
+    newProps
+  };
+}
+
+function performModifyNodeInPlaceMutation(mutationContext, mutation) {
+  const {
+    target,
+    newProps
+  } = mutation;
+
+  for (const [key, newPropValue] of Object.entries(newProps)) {
+    const prevPropValue = target[key]; // If the value did not change, skip.
+
+    if (prevPropValue === newPropValue) {
+      continue;
+    } // Mark removed nodes as deleted
+
+
+    if ((0, _hermesParser.isNode)(prevPropValue)) {
+      mutationContext.markDeletion(prevPropValue);
+    } else if (Array.isArray(prevPropValue)) {
+      for (const prevPropValueItem of prevPropValue) {
+        if ((0, _hermesParser.isNode)(prevPropValueItem)) {
+          mutationContext.markDeletion(prevPropValueItem);
+        }
+      }
+    } // Mark node property as mutated.
+
+
+    mutationContext.markMutation(target, key); // Assign new property.
+
+    target[key] = newPropValue;
+  }
+
+  return target;
+}

package/dist/transform/mutations/ModifyNodeInPlace.js.flow

@@ -0,0 +1,66 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+import type {ESNode} from 'hermes-estree';
+import type {MutationContext} from '../MutationContext';
+
+import {isNode} from 'hermes-parser';
+
+export type ModifyNodeInPlaceMutation = $ReadOnly<{
+  type: 'modifyNodeInPlace',
+  target: ESNode,
+  newProps: $ReadOnly<{...}>,
+}>;
+
+export function createModifyNodeInPlaceMutation(
+  target: ModifyNodeInPlaceMutation['target'],
+  newProps: ModifyNodeInPlaceMutation['newProps'],
+): ModifyNodeInPlaceMutation {
+  return {
+    type: 'modifyNodeInPlace',
+    target,
+    newProps,
+  };
+}
+
+export function performModifyNodeInPlaceMutation(
+  mutationContext: MutationContext,
+  mutation: ModifyNodeInPlaceMutation,
+): ESNode {
+  const {target, newProps} = mutation;
+
+  for (const [key, newPropValue] of Object.entries(newProps)) {
+    const prevPropValue = target[key];
+
+    // If the value did not change, skip.
+    if (prevPropValue === newPropValue) {
+      continue;
+    }
+
+    // Mark removed nodes as deleted
+    if (isNode(prevPropValue)) {
+      mutationContext.markDeletion(prevPropValue);
+    } else if (Array.isArray(prevPropValue)) {
+      for (const prevPropValueItem of prevPropValue) {
+        if (isNode(prevPropValueItem)) {
+          mutationContext.markDeletion(prevPropValueItem);
+        }
+      }
+    }
+
+    // Mark node property as mutated.
+    mutationContext.markMutation(target, key);
+
+    // Assign new property.
+    target[key] = newPropValue;
+  }
+
+  return target;
+}

package/dist/transform/print.js

@@ -29,28 +29,25 @@ const cacheBase = Math.random();
 
 async function print(ast, originalCode, prettierOptions = {}, visitorKeys) {
   // $FlowExpectedError[incompatible-type] This is now safe to access.
-  const program = ast; // The docblock comment is never attached to any AST nodes, since its technically
-  // attached to the program. However this is specific to our AST and in order for
-  // prettier to correctly print it we need to attach it to the first node in the
-  // program body.
-
-  if (program.docblock != null && program.body.length > 0) {
-    const firstNode = program.body[0];
-    const docblockComment = program.docblock.comment;
-    const leadingComments = (0, _comments.getLeadingCommentsForNode)(firstNode);
-
-    if (!leadingComments.includes(docblockComment)) {
-      (0, _comments.addCommentsToNode)(firstNode, [docblockComment], 'leading');
+  const program = ast; // If the AST body is empty, we can skip the cost of prettier by returning a static string of the contents.
+
+  if (program.body.length === 0) {
+    var _program$docblock;
+
+    // If the program had a docblock comment, we need to create the string manually.
+    const docblockComment = (_program$docblock = program.docblock) == null ? void 0 : _program$docblock.comment;
+
+    if (docblockComment != null) {
+      return '/*' + docblockComment.value + '*/\n';
     }
-  } // Fix up the AST to match what prettier expects.
+
+    return '';
+  } // Cleanup the comments from the AST and generate the "orginal" code needed for prettier.
 
 
-  (0, _hermesParser.mutateESTreeASTForPrettier)(program, visitorKeys); // we need to delete the comments prop or else prettier will do
-  // its own attachment pass after the mutation and duplicate the
-  // comments on each node, borking the output
-  // $FlowExpectedError[cannot-write]
+  const codeForPrinting = (0, _comments.mutateESTreeASTCommentsForPrettier)(program, originalCode); // Fix up the AST to match what prettier expects.
 
-  delete program.comments;
+  (0, _hermesParser.mutateESTreeASTForPrettier)(program, visitorKeys);
 
   switch (getPrettierMajorVersion()) {
     case '3':
@@ -58,7 +55,7 @@ async function print(ast, originalCode, prettierOptions = {}, visitorKeys) {
         // Lazy require this module as it only exists in prettier v3.
         const prettierFlowPlugin = require('prettier/plugins/flow');
 
-        return prettier.format(originalCode, // $FlowExpectedError[incompatible-exact] - we don't want to create a dependency on the prettier types
+        return prettier.format(codeForPrinting, // $FlowExpectedError[incompatible-exact] - we don't want to create a dependency on the prettier types
         { ...prettierOptions,
           parser: 'flow',
           requirePragma: false,
@@ -88,7 +85,7 @@ async function print(ast, originalCode, prettierOptions = {}, visitorKeys) {
           throw new Error('Hermes parser plugin not found');
         }
 
-        return prettier.format(originalCode, // $FlowExpectedError[incompatible-exact] - we don't want to create a dependency on the prettier types
+        return prettier.format(codeForPrinting, // $FlowExpectedError[incompatible-exact] - we don't want to create a dependency on the prettier types
         { ...prettierOptions,
           parser: 'hermes',
           requirePragma: false,

package/dist/transform/print.js.flow

@@ -15,10 +15,7 @@ import type {Program} from 'hermes-estree';
 
 import {mutateESTreeASTForPrettier} from 'hermes-parser';
 import * as prettier from 'prettier';
-import {
-  addCommentsToNode,
-  getLeadingCommentsForNode,
-} from './comments/comments';
+import {mutateESTreeASTCommentsForPrettier} from './comments/comments';
 import type {VisitorKeysType} from 'hermes-parser';
 
 let cache = 1;
@@ -33,34 +30,32 @@ export async function print(
   // $FlowExpectedError[incompatible-type] This is now safe to access.
   const program: Program = ast;
 
-  // The docblock comment is never attached to any AST nodes, since its technically
-  // attached to the program. However this is specific to our AST and in order for
-  // prettier to correctly print it we need to attach it to the first node in the
-  // program body.
-  if (program.docblock != null && program.body.length > 0) {
-    const firstNode = program.body[0];
-    const docblockComment = program.docblock.comment;
-    const leadingComments = getLeadingCommentsForNode(firstNode);
-    if (!leadingComments.includes(docblockComment)) {
-      addCommentsToNode(firstNode, [docblockComment], 'leading');
+  // If the AST body is empty, we can skip the cost of prettier by returning a static string of the contents.
+  if (program.body.length === 0) {
+    // If the program had a docblock comment, we need to create the string manually.
+    const docblockComment = program.docblock?.comment;
+    if (docblockComment != null) {
+      return '/*' + docblockComment.value + '*/\n';
     }
+
+    return '';
   }
 
+  // Cleanup the comments from the AST and generate the "orginal" code needed for prettier.
+  const codeForPrinting = mutateESTreeASTCommentsForPrettier(
+    program,
+    originalCode,
+  );
+
   // Fix up the AST to match what prettier expects.
   mutateESTreeASTForPrettier(program, visitorKeys);
 
-  // we need to delete the comments prop or else prettier will do
-  // its own attachment pass after the mutation and duplicate the
-  // comments on each node, borking the output
-  // $FlowExpectedError[cannot-write]
-  delete program.comments;
-
   switch (getPrettierMajorVersion()) {
     case '3': {
       // Lazy require this module as it only exists in prettier v3.
       const prettierFlowPlugin = require('prettier/plugins/flow');
       return prettier.format(
-        originalCode,
+        codeForPrinting,
         // $FlowExpectedError[incompatible-exact] - we don't want to create a dependency on the prettier types
         {
           ...prettierOptions,
@@ -89,7 +84,7 @@ export async function print(
       }
 
       return prettier.format(
-        originalCode,
+        codeForPrinting,
         // $FlowExpectedError[incompatible-exact] - we don't want to create a dependency on the prettier types
         {
           ...prettierOptions,

package/dist/transform/transformAST.js

@@ -38,6 +38,8 @@ var _ReplaceNode = require("./mutations/ReplaceNode");
 
 var _ReplaceStatementWithMany = require("./mutations/ReplaceStatementWithMany");
 
+var _ModifyNodeInPlace = require("./mutations/ModifyNodeInPlace");
+
 function transformAST({
   ast,
   scopeManager,
@@ -53,6 +55,11 @@ function transformAST({
   for (const mutation of transformContext.mutations) {
     const mutationRoot = (() => {
       switch (mutation.type) {
+        case 'modifyNodeInPlace':
+          {
+            return (0, _ModifyNodeInPlace.performModifyNodeInPlaceMutation)(mutationContext, mutation);
+          }
+
         case 'insertStatement':
           {
             return (0, _InsertStatement.performInsertStatementMutation)(mutationContext, mutation);

package/dist/transform/transformAST.js.flow

@@ -27,6 +27,7 @@ import {performRemoveNodeMutation} from './mutations/RemoveNode';
 import {performRemoveStatementMutation} from './mutations/RemoveStatement';
 import {performReplaceNodeMutation} from './mutations/ReplaceNode';
 import {performReplaceStatementWithManyMutation} from './mutations/ReplaceStatementWithMany';
+import {performModifyNodeInPlaceMutation} from './mutations/ModifyNodeInPlace';
 
 export type TransformASTResult = {
   ast: Program,
@@ -56,6 +57,10 @@ export function transformAST(
   for (const mutation of transformContext.mutations) {
     const mutationRoot = ((): ESNode | null => {
       switch (mutation.type) {
+        case 'modifyNodeInPlace': {
+          return performModifyNodeInPlaceMutation(mutationContext, mutation);
+        }
+
         case 'insertStatement': {
           return performInsertStatementMutation(mutationContext, mutation);
         }

package/package.json

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