hermes-transform 0.6.0 → 0.9.0

package/dist/transform/comments/comments.js

@@ -3,14 +3,16 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.CommentPlacement = void 0;
+exports.addComment = addComment;
 exports.addCommentsToNode = addCommentsToNode;
-exports.addLeadingComment = addLeadingComment;
-exports.addTrailingComment = addTrailingComment;
 exports.appendCommentToSource = appendCommentToSource;
 exports.attachComments = attachComments;
 exports.cloneComment = cloneComment;
 exports.cloneCommentWithMarkers = cloneCommentWithMarkers;
 exports.getCommentsForNode = getCommentsForNode;
+exports.getLeadingCommentsForNode = getLeadingCommentsForNode;
+exports.getTrailingCommentsForNode = getTrailingCommentsForNode;
 exports.isLeadingComment = isLeadingComment;
 exports.isTrailingComment = isTrailingComment;
 exports.moveCommentsToNewNode = moveCommentsToNewNode;
@@ -24,6 +26,8 @@ var _printerEstree = _interopRequireDefault(require("./prettier/language-js/prin
 
 var _util = require("./prettier/common/util");
 
+var _os = require("os");
+
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 /**
@@ -38,6 +42,10 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
 // $FlowExpectedError[untyped-import]
 // $FlowExpectedError[untyped-import]
 // $FlowExpectedError[untyped-import]
+const CommentPlacement = require("flow-enums-runtime").Mirrored(["LEADING_OWN_LINE", "LEADING_INLINE", "TRAILING_OWN_LINE", "TRAILING_INLINE"]);
+
+exports.CommentPlacement = CommentPlacement;
+
 function attachComments(comments, ast, text) {
   (0, _comments.attach)(comments, ast, text, {
     locStart: _loc.locStart,
@@ -56,13 +64,21 @@ function setCommentsOnNode(node, comments) {
   node.comments = comments;
 }
 
-function addCommentsToNode(node, comments) {
+function addCommentsToNode(node, comments, side = 'trailing') {
   var _node$comments;
 
-  // $FlowExpectedError - this property is secretly added by prettier.
-  node.comments = (_node$comments = node.comments) != null ? _node$comments : []; // $FlowExpectedError
-
-  node.comments.push(...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);
+  }
 }
 
 function getCommentsForNode(node) {
@@ -82,12 +98,30 @@ function isTrailingComment(comment) {
   return comment.trailing === true;
 }
 
-function addLeadingComment(node, comment) {
-  (0, _util.addLeadingComment)(node, comment);
+function getLeadingCommentsForNode(node) {
+  return getCommentsForNode(node).filter(isLeadingComment);
+}
+
+function getTrailingCommentsForNode(node) {
+  return getCommentsForNode(node).filter(isTrailingComment);
 }
 
-function addTrailingComment(node, comment) {
-  (0, _util.addTrailingComment)(node, comment);
+function addComment(node, comment, placement) {
+  switch (placement) {
+    case CommentPlacement.LEADING_OWN_LINE:
+    case CommentPlacement.LEADING_INLINE:
+      {
+        (0, _util.addLeadingComment)(node, comment);
+        break;
+      }
+
+    case CommentPlacement.TRAILING_OWN_LINE:
+    case CommentPlacement.TRAILING_INLINE:
+      {
+        (0, _util.addTrailingComment)(node, comment);
+        break;
+      }
+  }
 }
 
 function cloneComment(comment) {
@@ -112,29 +146,100 @@ function cloneCommentWithMarkers(comment) {
   };
 }
 
-function appendCommentToSource(code, comment) {
-  // prettier slices comments directly from the source code when printing
-  // https://github.com/prettier/prettier/blob/5f0ee39fa03532c85bd1c35291450fe7ac3667b3/src/language-js/print/comment.js#L15-L20
-  // this means that we need to have any appended comments directly in the
-  // source code or else prettier will slice nothing and bork up the transform
-  let commentText = comment.value;
+function getFirstNewlineIndex(code) {
+  return code.search(/\r\n|\n|\r/);
+}
+
+function getFirstNonWhitespaceIndex(code) {
+  return code.search(/\S/);
+}
+
+function appendCommentToSource(code, comment, placement) {
+  let newCode = code;
 
   switch (comment.type) {
     case 'Block':
-      commentText = `/*${commentText}*/`;
-      break;
+      {
+        // Prettier decides if a newline is necessary between the comment and its node by looking
+        // to see if a newline seperates them in the source text. We can trick prettier into
+        // formatting how we want for new comments by placing the range such that a newline
+        // will (OWN_LINE) or will not (INLINE) be found when searching from the specified range
+        // position.
+        switch (placement) {
+          case CommentPlacement.LEADING_OWN_LINE:
+          case CommentPlacement.TRAILING_OWN_LINE:
+            {
+              // Since we always want a line break we need to ensure a newline is found when
+              // searching out from either side of the comment range.
+              let firstNewline = getFirstNewlineIndex(code);
+
+              if (firstNewline === -1) {
+                // No newline in file, lets add one.
+                newCode += _os.EOL;
+                firstNewline = newCode.length;
+              } // Prettier only uses these ranges for detecting whitespace, so this nonsensical
+              // range is safe.
+              // $FlowExpectedError[cannot-write]
+
+
+              comment.range = [firstNewline + 1, firstNewline];
+              break;
+            }
+
+          case CommentPlacement.LEADING_INLINE:
+          case CommentPlacement.TRAILING_INLINE:
+            {
+              // Since we don't want a line break we need to ensure a non whitespace char is
+              // always found before a newline when searching out from either side of the
+              // comment range.
+              let firstNonWhitespace = getFirstNonWhitespaceIndex(code);
+
+              if (firstNonWhitespace === -1) {
+                // No non whitespace chars in file, lets add an identifiable statement for prettier to find.
+                newCode += '$FORCE_INLINE_ON_EMPTY_FILE_TOKEN$;';
+                firstNonWhitespace = newCode.length;
+                break;
+              } // $FlowExpectedError[cannot-write]
+
+
+              comment.range = [firstNonWhitespace + 1, firstNonWhitespace];
+              break;
+            }
+        }
+
+        break;
+      }
 
     case 'Line':
-      commentText = `//${commentText}`;
-      break;
+      {
+        // For `Line` comments prettier slices comments directly from the source code when printing
+        // https://github.com/prettier/prettier/blob/5f0ee39fa03532c85bd1c35291450fe7ac3667b3/src/language-js/print/comment.js#L15-L20
+        // this means that we need to have any appended comments directly in the
+        // source code or else prettier will slice nothing and bork up the transform
+        const commentText = `//${comment.value}`;
+        const lastChar = newCode[newCode.length - 1];
+
+        if (lastChar !== '\n' && lastChar !== '\r') {
+          newCode += _os.EOL;
+        } // Line comments cannot be inline before a node so we only place trailing Line comments inline.
+
+
+        if (placement === CommentPlacement.TRAILING_INLINE) {
+          // Prettier determines an "end of line" comment by walking backwards from
+          // the comment start range through the source code to see if it finds a non
+          // newline token. In order to trick prettier for new comments we need to
+          // insert fake source code for it to find.
+          newCode += '$FORCE_END_OF_LINE_COMMENT_TOKEN$;';
+        }
+
+        const start = newCode.length;
+        newCode += commentText;
+        const end = newCode.length; // $FlowExpectedError[cannot-write]
+
+        comment.range = [start, end];
+        break;
+      }
   }
 
-  let newCode = code;
-  newCode += '\n';
-  const start = newCode.length;
-  newCode += commentText;
-  const end = newCode.length; // $FlowExpectedError[cannot-write]
-
-  comment.range = [start, end];
   return newCode;
 }

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

@@ -23,9 +23,17 @@ import {
   // $FlowExpectedError[untyped-import]
   addTrailingComment as untypedAddTrailingComment,
 } from './prettier/common/util';
+import {EOL} from 'os';
 
 export type Options = $ReadOnly<{}>;
 
+export enum CommentPlacement {
+  LEADING_OWN_LINE,
+  LEADING_INLINE,
+  TRAILING_OWN_LINE,
+  TRAILING_INLINE,
+}
+
 export function attachComments(
   comments: $ReadOnlyArray<Comment>,
   ast: Program,
@@ -57,11 +65,19 @@ export function setCommentsOnNode(
 export function addCommentsToNode(
   node: ESNode | DetachedNode<ESNode>,
   comments: $ReadOnlyArray<Comment>,
+  side?: 'leading' | 'trailing' = 'trailing',
 ): void {
-  // $FlowExpectedError - this property is secretly added by prettier.
+  // $FlowExpectedError[prop-missing] - this property is secretly added by prettier.
+  // $FlowExpectedError[cannot-write]
+  // $FlowExpectedError[incompatible-use]
   node.comments = node.comments ?? [];
-  // $FlowExpectedError
-  (node.comments: Array<Comment>).push(...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(
@@ -80,18 +96,35 @@ export function isTrailingComment(comment: Comment): boolean {
   return comment.trailing === true;
 }
 
-export function addLeadingComment(
+export function getLeadingCommentsForNode(
   node: ESNode | DetachedNode<ESNode>,
-  comment: Comment,
-): void {
-  untypedAddLeadingComment(node, comment);
+): $ReadOnlyArray<Comment> {
+  return getCommentsForNode(node).filter(isLeadingComment);
+}
+
+export function getTrailingCommentsForNode(
+  node: ESNode | DetachedNode<ESNode>,
+): $ReadOnlyArray<Comment> {
+  return getCommentsForNode(node).filter(isTrailingComment);
 }
 
-export function addTrailingComment(
+export function addComment(
   node: ESNode | DetachedNode<ESNode>,
   comment: Comment,
+  placement: CommentPlacement,
 ): void {
-  untypedAddTrailingComment(node, comment);
+  switch (placement) {
+    case CommentPlacement.LEADING_OWN_LINE:
+    case CommentPlacement.LEADING_INLINE: {
+      untypedAddLeadingComment(node, comment);
+      break;
+    }
+    case CommentPlacement.TRAILING_OWN_LINE:
+    case CommentPlacement.TRAILING_INLINE: {
+      untypedAddTrailingComment(node, comment);
+      break;
+    }
+  }
 }
 
 export function cloneComment<T: Comment>(comment: T): T {
@@ -116,30 +149,94 @@ export function cloneCommentWithMarkers<T: Comment>(comment: T): T {
   };
 }
 
-export function appendCommentToSource(code: string, comment: Comment): string {
-  // prettier slices comments directly from the source code when printing
-  // https://github.com/prettier/prettier/blob/5f0ee39fa03532c85bd1c35291450fe7ac3667b3/src/language-js/print/comment.js#L15-L20
-  // this means that we need to have any appended comments directly in the
-  // source code or else prettier will slice nothing and bork up the transform
+function getFirstNewlineIndex(code: string): number {
+  return code.search(/\r\n|\n|\r/);
+}
+
+function getFirstNonWhitespaceIndex(code: string): number {
+  return code.search(/\S/);
+}
 
-  let commentText = comment.value;
+export function appendCommentToSource(
+  code: string,
+  comment: Comment,
+  placement: CommentPlacement,
+): string {
+  let newCode = code;
   switch (comment.type) {
-    case 'Block':
-      commentText = `/*${commentText}*/`;
+    case 'Block': {
+      // Prettier decides if a newline is necessary between the comment and its node by looking
+      // to see if a newline seperates them in the source text. We can trick prettier into
+      // formatting how we want for new comments by placing the range such that a newline
+      // will (OWN_LINE) or will not (INLINE) be found when searching from the specified range
+      // position.
+      switch (placement) {
+        case CommentPlacement.LEADING_OWN_LINE:
+        case CommentPlacement.TRAILING_OWN_LINE: {
+          // Since we always want a line break we need to ensure a newline is found when
+          // searching out from either side of the comment range.
+          let firstNewline = getFirstNewlineIndex(code);
+          if (firstNewline === -1) {
+            // No newline in file, lets add one.
+            newCode += EOL;
+            firstNewline = newCode.length;
+          }
+          // Prettier only uses these ranges for detecting whitespace, so this nonsensical
+          // range is safe.
+          // $FlowExpectedError[cannot-write]
+          comment.range = [firstNewline + 1, firstNewline];
+          break;
+        }
+        case CommentPlacement.LEADING_INLINE:
+        case CommentPlacement.TRAILING_INLINE: {
+          // Since we don't want a line break we need to ensure a non whitespace char is
+          // always found before a newline when searching out from either side of the
+          // comment range.
+          let firstNonWhitespace = getFirstNonWhitespaceIndex(code);
+          if (firstNonWhitespace === -1) {
+            // No non whitespace chars in file, lets add an identifiable statement for prettier to find.
+            newCode += '$FORCE_INLINE_ON_EMPTY_FILE_TOKEN$;';
+            firstNonWhitespace = newCode.length;
+            break;
+          }
+
+          // $FlowExpectedError[cannot-write]
+          comment.range = [firstNonWhitespace + 1, firstNonWhitespace];
+          break;
+        }
+      }
       break;
-    case 'Line':
-      commentText = `//${commentText}`;
+    }
+    case 'Line': {
+      // For `Line` comments prettier slices comments directly from the source code when printing
+      // https://github.com/prettier/prettier/blob/5f0ee39fa03532c85bd1c35291450fe7ac3667b3/src/language-js/print/comment.js#L15-L20
+      // this means that we need to have any appended comments directly in the
+      // source code or else prettier will slice nothing and bork up the transform
+      const commentText = `//${comment.value}`;
+
+      const lastChar = newCode[newCode.length - 1];
+      if (lastChar !== '\n' && lastChar !== '\r') {
+        newCode += EOL;
+      }
+
+      // Line comments cannot be inline before a node so we only place trailing Line comments inline.
+      if (placement === CommentPlacement.TRAILING_INLINE) {
+        // Prettier determines an "end of line" comment by walking backwards from
+        // the comment start range through the source code to see if it finds a non
+        // newline token. In order to trick prettier for new comments we need to
+        // insert fake source code for it to find.
+        newCode += '$FORCE_END_OF_LINE_COMMENT_TOKEN$;';
+      }
+      const start = newCode.length;
+      newCode += commentText;
+      const end = newCode.length;
+
+      // $FlowExpectedError[cannot-write]
+      comment.range = [start, end];
+
       break;
+    }
   }
 
-  let newCode = code;
-  newCode += '\n';
-  const start = newCode.length;
-  newCode += commentText;
-  const end = newCode.length;
-
-  // $FlowExpectedError[cannot-write]
-  comment.range = [start, end];
-
   return newCode;
 }

package/dist/transform/getTransformedAST.js

@@ -26,9 +26,7 @@ var _TransformContext = require("./TransformContext");
 
 var _comments = require("./comments/comments");
 
-var _AddLeadingComments = require("./mutations/AddLeadingComments");
-
-var _AddTrailingComments = require("./mutations/AddTrailingComments");
+var _AddComments = require("./mutations/AddComments");
 
 var _CloneCommentsTo = require("./mutations/CloneCommentsTo");
 
@@ -55,8 +53,8 @@ function getTransformedAST(code, visitors) {
 
   (0, _comments.attachComments)(ast.comments, ast, code); // traverse the AST and colllect the mutations
 
-  const transformContext = (0, _TransformContext.getTransformContext)(code);
-  (0, _traverse.traverseWithContext)(ast, scopeManager, () => transformContext, visitors); // apply the mutations to the AST
+  const transformContext = (0, _TransformContext.getTransformContext)();
+  (0, _traverse.traverseWithContext)(code, ast, scopeManager, () => transformContext, visitors); // apply the mutations to the AST
 
   const mutationContext = new _MutationContext.MutationContext(code);
   const removeCommentMutations = [];
@@ -96,14 +94,9 @@ function getTransformedAST(code, visitors) {
             return null;
           }
 
-        case 'addLeadingComments':
-          {
-            return (0, _AddLeadingComments.performAddLeadingCommentsMutation)(mutationContext, mutation);
-          }
-
-        case 'addTrailingComments':
+        case 'addComments':
           {
-            return (0, _AddTrailingComments.performAddTrailingCommentsMutation)(mutationContext, mutation);
+            return (0, _AddComments.performAddCommentsMutation)(mutationContext, mutation);
           }
 
         case 'cloneCommentsTo':
@@ -129,6 +122,21 @@ function getTransformedAST(code, visitors) {
     if (mutationRoot) {
       (0, _detachedNode.updateAllParentPointers)(mutationRoot);
     }
+  } // if the very first node in the program is replaced, it will take the docblock with it
+  // this is bad as it means we'll lose `@format`, ``, licence, etc.
+  // so this hack just makes sure that we keep the docblock
+  // note that we do this **BEFORE** the comment mutations in case someone intentionally
+  // wants to remove the docblock comment for some weird reason
+
+
+  if (ast.docblock != null && ast.body.length > 0) {
+    const firstNode = ast.body[0];
+    const docblockComment = ast.docblock.comment;
+    const leadingComments = (0, _comments.getLeadingCommentsForNode)(firstNode);
+
+    if (!leadingComments.includes(docblockComment)) {
+      (0, _comments.addCommentsToNode)(firstNode, [docblockComment], 'leading');
+    }
   } // remove the comments
   // this is done at the end because it requires a complete traversal of the AST
   // so that we can find relevant node's attachment array

package/dist/transform/getTransformedAST.js.flow

@@ -11,8 +11,7 @@
 'use strict';
 
 import type {ESNode, Program} from 'hermes-estree';
-import type {Visitor} from '../traverse/traverse';
-import type {TransformContext} from './TransformContext';
+import type {TransformVisitor} from './transform';
 import type {RemoveCommentMutation} from './mutations/RemoveComment';
 
 import {parseForESLint} from 'hermes-eslint';
@@ -20,9 +19,12 @@ import {updateAllParentPointers} from '../detachedNode';
 import {traverseWithContext} from '../traverse/traverse';
 import {MutationContext} from './MutationContext';
 import {getTransformContext} from './TransformContext';
-import {attachComments} from './comments/comments';
-import {performAddLeadingCommentsMutation} from './mutations/AddLeadingComments';
-import {performAddTrailingCommentsMutation} from './mutations/AddTrailingComments';
+import {
+  addCommentsToNode,
+  attachComments,
+  getLeadingCommentsForNode,
+} from './comments/comments';
+import {performAddCommentsMutation} from './mutations/AddComments';
 import {performCloneCommentsToMutation} from './mutations/CloneCommentsTo';
 import {performInsertStatementMutation} from './mutations/InsertStatement';
 import {performRemoveCommentMutations} from './mutations/RemoveComment';
@@ -33,7 +35,7 @@ import {performReplaceStatementWithManyMutation} from './mutations/ReplaceStatem
 
 export function getTransformedAST(
   code: string,
-  visitors: Visitor<TransformContext>,
+  visitors: TransformVisitor,
 ): {
   ast: Program,
   astWasMutated: boolean,
@@ -48,8 +50,14 @@ export function getTransformedAST(
   attachComments(ast.comments, ast, code);
 
   // traverse the AST and colllect the mutations
-  const transformContext = getTransformContext(code);
-  traverseWithContext(ast, scopeManager, () => transformContext, visitors);
+  const transformContext = getTransformContext();
+  traverseWithContext(
+    code,
+    ast,
+    scopeManager,
+    () => transformContext,
+    visitors,
+  );
 
   // apply the mutations to the AST
   const mutationContext = new MutationContext(code);
@@ -88,12 +96,8 @@ export function getTransformedAST(
           return null;
         }
 
-        case 'addLeadingComments': {
-          return performAddLeadingCommentsMutation(mutationContext, mutation);
-        }
-
-        case 'addTrailingComments': {
-          return performAddTrailingCommentsMutation(mutationContext, mutation);
+        case 'addComments': {
+          return performAddCommentsMutation(mutationContext, mutation);
         }
 
         case 'cloneCommentsTo': {
@@ -120,6 +124,20 @@ export function getTransformedAST(
     }
   }
 
+  // if the very first node in the program is replaced, it will take the docblock with it
+  // this is bad as it means we'll lose `@format`, `@flow`, licence, etc.
+  // so this hack just makes sure that we keep the docblock
+  // note that we do this **BEFORE** the comment mutations in case someone intentionally
+  // wants to remove the docblock comment for some weird reason
+  if (ast.docblock != null && ast.body.length > 0) {
+    const firstNode = ast.body[0];
+    const docblockComment = ast.docblock.comment;
+    const leadingComments = getLeadingCommentsForNode(firstNode);
+    if (!leadingComments.includes(docblockComment)) {
+      addCommentsToNode(firstNode, [docblockComment], 'leading');
+    }
+  }
+
   // remove the comments
   // this is done at the end because it requires a complete traversal of the AST
   // so that we can find relevant node's attachment array

package/dist/transform/mutations/{AddLeadingComments.js → AddComments.js}

@@ -3,8 +3,8 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.createAddLeadingCommentsMutation = createAddLeadingCommentsMutation;
-exports.performAddLeadingCommentsMutation = performAddLeadingCommentsMutation;
+exports.createAddCommentsMutation = createAddCommentsMutation;
+exports.performAddCommentsMutation = performAddCommentsMutation;
 
 var _comments = require("../comments/comments");
 
@@ -17,23 +17,26 @@ var _comments = require("../comments/comments");
  * 
  * @format
  */
-function createAddLeadingCommentsMutation(node, comments) {
+function createAddCommentsMutation(node, comments) {
   if (comments.length === 0) {
     return null;
   }
 
   return {
-    type: 'addLeadingComments',
+    type: 'addComments',
     comments,
     node
   };
 }
 
-function performAddLeadingCommentsMutation(mutationContext, mutation) {
-  for (const originalComment of mutation.comments) {
+function performAddCommentsMutation(mutationContext, mutation) {
+  for (const {
+    comment: originalComment,
+    placement
+  } of mutation.comments) {
     const comment = (0, _comments.cloneComment)(originalComment);
-    mutationContext.appendCommentToSource(comment);
-    (0, _comments.addLeadingComment)(mutation.node, comment);
+    mutationContext.appendCommentToSource(comment, placement);
+    (0, _comments.addComment)(mutation.node, comment, placement);
   }
 
   return null;

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

@@ -0,0 +1,50 @@
+/**
+ * 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 {Comment, ESNode} from 'hermes-estree';
+import type {DetachedNode} from '../../detachedNode';
+import type {MutationContext} from '../MutationContext';
+import type {CommentPlacement} from '../comments/comments';
+
+import {addComment, cloneComment} from '../comments/comments';
+
+export type AddCommentsMutation = $ReadOnly<{
+  type: 'addComments',
+  comments: $ReadOnlyArray<{comment: Comment, placement: CommentPlacement}>,
+  node: ESNode | DetachedNode<ESNode>,
+}>;
+
+export function createAddCommentsMutation(
+  node: AddCommentsMutation['node'],
+  comments: AddCommentsMutation['comments'],
+): ?AddCommentsMutation {
+  if (comments.length === 0) {
+    return null;
+  }
+
+  return {
+    type: 'addComments',
+    comments,
+    node,
+  };
+}
+
+export function performAddCommentsMutation(
+  mutationContext: MutationContext,
+  mutation: AddCommentsMutation,
+): null {
+  for (const {comment: originalComment, placement} of mutation.comments) {
+    const comment = cloneComment(originalComment);
+    mutationContext.appendCommentToSource(comment, placement);
+    addComment(mutation.node, comment, placement);
+  }
+
+  return null;
+}

package/dist/transform/mutations/CloneCommentsTo.js

@@ -25,12 +25,11 @@ function createCloneCommentsToMutation(target, destination) {
   };
 }
 
-function performCloneCommentsToMutation(mutationContext, mutation) {
+function performCloneCommentsToMutation(_mutationContext, mutation) {
   const newComments = [];
 
   for (const originalComment of (0, _comments.getCommentsForNode)(mutation.target)) {
     const comment = (0, _comments.cloneCommentWithMarkers)(originalComment);
-    mutationContext.appendCommentToSource(comment);
     newComments.push(comment);
   }