hermes-transform 0.36.1 → 0.37.0

package/dist/transform/TransformContext.js

@@ -29,19 +29,7 @@ var _ReplaceStatementWithMany = require("./mutations/ReplaceStatementWithMany");
 
 var _ModifyNodeInPlace = require("./mutations/ModifyNodeInPlace");
 
-/**
- * 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 getTransformContext() {
-  /**
-   * The mutations in order of collection.
-   */
   const mutations = [];
 
   function pushMutation(mutation) {
@@ -51,7 +39,6 @@ function getTransformContext() {
   }
 
   const cloneAPIs = {
-    // $FlowFixMe[incompatible-exact]
     shallowCloneNode: node => {
       if (node == null) {
         return null;
@@ -66,7 +53,6 @@ function getTransformContext() {
 
       return (0, _detachedNode.shallowCloneNode)(node, newProps);
     },
-    // $FlowFixMe[incompatible-exact]
     shallowCloneArray: nodes => {
       if (nodes == null) {
         return null;
@@ -76,14 +62,12 @@ function getTransformContext() {
         const node = node_;
 
         if (node == null) {
-          // $FlowExpectedError[incompatible-type]
           return node;
         }
 
         return (0, _detachedNode.shallowCloneNode)(node, {});
       });
     },
-    // $FlowFixMe[incompatible-exact]
     deepCloneNode: node => {
       if (node == null) {
         return null;
@@ -176,7 +160,6 @@ function getTransformContext() {
 
       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 {
@@ -190,7 +173,6 @@ function getTransformContext() {
   return {
     mutations,
 
-    // $FlowExpectedError[unsafe-getters-setters]
     get astWasMutated() {
       return mutations.length > 0;
     },

package/dist/transform/TransformContext.js.flow

@@ -54,7 +54,7 @@ import {createReplaceNodeMutation} from './mutations/ReplaceNode';
 import {createReplaceStatementWithManyMutation} from './mutations/ReplaceStatementWithMany';
 import {createModifyNodeInPlaceMutation} from './mutations/ModifyNodeInPlace';
 
-type Mutation = $ReadOnly<
+type Mutation = Readonly<
   | AddCommentsMutation
   | CloneCommentsToMutation
   | InsertStatementMutation
@@ -66,9 +66,9 @@ type Mutation = $ReadOnly<
   | ModifyNodeInPlaceMutation,
 >;
 
-type SingleOrArray<+T> = T | $ReadOnlyArray<T>;
+type SingleOrArray<out T> = T | ReadonlyArray<T>;
 
-type ReplaceNodeOptions = $ReadOnly<{
+type ReplaceNodeOptions = Readonly<{
   /**
    * Moves the comments from the target node to the nodetoReplaceWith.
    * Note that this does not *clone* comments, it moves them and clears out
@@ -77,7 +77,7 @@ type ReplaceNodeOptions = $ReadOnly<{
   keepComments?: boolean,
 }>;
 
-type TransformCloneAPIs = $ReadOnly<{
+type TransformCloneAPIs = Readonly<{
   /**
    * Shallowly clones the given node.
    *
@@ -95,8 +95,8 @@ type TransformCloneAPIs = $ReadOnly<{
    * in the AST, then use `deepCloneNode` instead.
    */
   shallowCloneNode: {
-    <T: ESNode>(node: T): DetachedNode<T>,
-    <T: ESNode>(node: ?T): DetachedNode<T> | null,
+    <T extends ESNode>(node: T): DetachedNode<T>,
+    <T extends ESNode>(node: ?T): DetachedNode<T> | null,
   },
 
   /**
@@ -109,10 +109,16 @@ type TransformCloneAPIs = $ReadOnly<{
    * {@see shallowCloneNode}
    */
   shallowCloneArray: {
-    <T: ESNode>(node: $ReadOnlyArray<T>): $ReadOnlyArray<DetachedNode<T>>,
-    <T: ESNode>(node: ?$ReadOnlyArray<T>): ?$ReadOnlyArray<DetachedNode<T>>,
-    <T: ESNode>(node: $ReadOnlyArray<?T>): $ReadOnlyArray<DetachedNode<?T>>,
-    <T: ESNode>(node: ?$ReadOnlyArray<?T>): ?$ReadOnlyArray<DetachedNode<?T>>,
+    <T extends ESNode>(node: ReadonlyArray<T>): ReadonlyArray<DetachedNode<T>>,
+    <T extends ESNode>(
+      node: ?ReadonlyArray<T>,
+    ): ?ReadonlyArray<DetachedNode<T>>,
+    <T extends ESNode>(
+      node: ReadonlyArray<?T>,
+    ): ReadonlyArray<DetachedNode<?T>>,
+    <T extends ESNode>(
+      node: ?ReadonlyArray<?T>,
+    ): ?ReadonlyArray<DetachedNode<?T>>,
   },
 
   /**
@@ -123,8 +129,8 @@ type TransformCloneAPIs = $ReadOnly<{
    * result in a lot of work being done.
    */
   deepCloneNode: {
-    <T: ESNode>(node: T): DetachedNode<T>,
-    <T: ESNode>(node: ?T): DetachedNode<T> | null,
+    <T extends ESNode>(node: T): DetachedNode<T>,
+    <T extends ESNode>(node: ?T): DetachedNode<T> | null,
   },
 
   /**
@@ -135,7 +141,7 @@ type TransformCloneAPIs = $ReadOnly<{
   deepCloneNodeWithOverrides: TransformCloneSignatures,
 }>;
 
-type TransformCommentAPIs = $ReadOnly<{
+type TransformCommentAPIs = Readonly<{
   /**
    * Gets all of the comments attached to the given node.
    */
@@ -199,7 +205,7 @@ type TransformCommentAPIs = $ReadOnly<{
   removeComments: (comments: SingleOrArray<Comment>) => void,
 }>;
 
-type TransformInsertAPIs = $ReadOnly<{
+type TransformInsertAPIs = Readonly<{
   /**
    * Insert `nodeToInsert` after the `target` statement.
    * The inserted nodes will be kept in the order given.
@@ -223,7 +229,7 @@ type TransformInsertAPIs = $ReadOnly<{
   ) => void,
 }>;
 
-type TransformModifyAPIs = $ReadOnly<{
+type TransformModifyAPIs = Readonly<{
   /**
    * Modifies a given node in place.
    * This is equivalent to doing a replace with a shallow clone with overrides.
@@ -231,7 +237,7 @@ type TransformModifyAPIs = $ReadOnly<{
   modifyNodeInPlace: TransformModifySignatures,
 }>;
 
-type TransformRemoveAPIs = $ReadOnly<{
+type TransformRemoveAPIs = Readonly<{
   /**
    * Removes a given node from the AST.
    * The set of thigns that can be removed is intentionally restricted by types.
@@ -245,7 +251,7 @@ type TransformRemoveAPIs = $ReadOnly<{
   removeStatement: (node: RemoveStatementMutation['node']) => void,
 }>;
 
-type TransformReplaceAPIs = $ReadOnly<{
+type TransformReplaceAPIs = Readonly<{
   /**
    * Replace the `target` node with the `nodeToReplaceWith` node.
    * This simply does an in-place replacement in the AST.
@@ -295,7 +301,7 @@ type TransformReplaceAPIs = $ReadOnly<{
    */
   replaceStatementWithMany: (
     target: ReplaceStatementWithManyMutation['target'],
-    nodesToReplaceWith: $ReadOnlyArray<
+    nodesToReplaceWith: ReadonlyArray<
       MaybeDetachedNode<ReplaceStatementWithManyMutationNodes>,
     >,
     options?: {
@@ -309,8 +315,8 @@ type TransformReplaceAPIs = $ReadOnly<{
   ) => void,
 }>;
 
-export type TransformContextAdditions = $ReadOnly<{
-  mutations: $ReadOnlyArray<Mutation>,
+export type TransformContextAdditions = Readonly<{
+  mutations: ReadonlyArray<Mutation>,
   astWasMutated: boolean,
 
   ...TransformCommentAPIs,
@@ -335,17 +341,17 @@ export function getTransformContext(): TransformContextAdditions {
 
   const cloneAPIs: TransformCloneAPIs = {
     // $FlowFixMe[incompatible-exact]
-    shallowCloneNode: (((node: ?ESNode): ?DetachedNode<ESNode> => {
+    shallowCloneNode: ((node: ?ESNode): ?DetachedNode<ESNode> => {
       if (node == null) {
         return null;
       }
 
       return shallowCloneNode(node, {});
-    }: $FlowFixMe): TransformCloneAPIs['shallowCloneNode']),
+    }) as $FlowFixMe as TransformCloneAPIs['shallowCloneNode'],
 
-    shallowCloneNodeWithOverrides: (((
+    shallowCloneNodeWithOverrides: ((
       node: ?ESNode,
-      newProps?: $ReadOnly<{...}> = {},
+      newProps?: Readonly<{...}> = {},
     ): // $FlowExpectedError[prop-missing]
     ?DetachedNode<ESNode> => {
       if (node == null) {
@@ -353,12 +359,12 @@ export function getTransformContext(): TransformContextAdditions {
       }
 
       return shallowCloneNode(node, newProps);
-    }: $FlowFixMe): TransformCloneAPIs['shallowCloneNodeWithOverrides']),
+    }) as $FlowFixMe as TransformCloneAPIs['shallowCloneNodeWithOverrides'],
 
     // $FlowFixMe[incompatible-exact]
-    shallowCloneArray: ((<T: ESNode>(
-      nodes: ?$ReadOnlyArray<?T>,
-    ): ?$ReadOnlyArray<DetachedNode<?ESNode>> => {
+    shallowCloneArray: (<T extends ESNode>(
+      nodes: ?ReadonlyArray<?T>,
+    ): ?ReadonlyArray<DetachedNode<?ESNode>> => {
       if (nodes == null) {
         return null;
       }
@@ -371,20 +377,20 @@ export function getTransformContext(): TransformContextAdditions {
         }
         return shallowCloneNode<ESNode>(node, {});
       });
-    }: $FlowFixMe): TransformCloneAPIs['shallowCloneArray']),
+    }) as $FlowFixMe as TransformCloneAPIs['shallowCloneArray'],
 
     // $FlowFixMe[incompatible-exact]
-    deepCloneNode: (((node: ?ESNode): ?DetachedNode<ESNode> => {
+    deepCloneNode: ((node: ?ESNode): ?DetachedNode<ESNode> => {
       if (node == null) {
         return null;
       }
 
       return deepCloneNode(node, {});
-    }: $FlowFixMe): TransformCloneAPIs['deepCloneNode']),
+    }) as $FlowFixMe as TransformCloneAPIs['deepCloneNode'],
 
-    deepCloneNodeWithOverrides: (((
+    deepCloneNodeWithOverrides: ((
       node: ?ESNode,
-      newProps?: $ReadOnly<{...}> = {},
+      newProps?: Readonly<{...}> = {},
     ): // $FlowExpectedError[prop-missing]
     ?DetachedNode<ESNode> => {
       if (node == null) {
@@ -392,24 +398,24 @@ export function getTransformContext(): TransformContextAdditions {
       }
 
       return deepCloneNode(node, newProps);
-    }: $FlowFixMe): TransformCloneAPIs['deepCloneNodeWithOverrides']),
+    }) as $FlowFixMe as TransformCloneAPIs['deepCloneNodeWithOverrides'],
   };
   const commentAPIs: TransformCommentAPIs = {
     getComments: ((node): Array<Comment> => {
       return [...getCommentsForNode(node)];
-    }: TransformCommentAPIs['getComments']),
+    }) as TransformCommentAPIs['getComments'],
 
     getLeadingComments: ((node): Array<Comment> => {
       return getCommentsForNode(node).filter(isLeadingComment);
-    }: TransformCommentAPIs['getLeadingComments']),
+    }) as TransformCommentAPIs['getLeadingComments'],
 
     getTrailingComments: ((node): Array<Comment> => {
       return getCommentsForNode(node).filter(isTrailingComment);
-    }: TransformCommentAPIs['getTrailingComments']),
+    }) as TransformCommentAPIs['getTrailingComments'],
 
     cloneCommentsTo: ((target, destination): void => {
       pushMutation(createCloneCommentsToMutation(target, destination));
-    }: TransformCommentAPIs['cloneCommentsTo']),
+    }) as TransformCommentAPIs['cloneCommentsTo'],
 
     addLeadingComments: ((node, comments): void => {
       pushMutation(
@@ -421,7 +427,7 @@ export function getTransformContext(): TransformContextAdditions {
           })),
         ),
       );
-    }: TransformCommentAPIs['addLeadingComments']),
+    }) as TransformCommentAPIs['addLeadingComments'],
 
     addLeadingInlineComments: ((node, comments): void => {
       pushMutation(
@@ -433,7 +439,7 @@ export function getTransformContext(): TransformContextAdditions {
           })),
         ),
       );
-    }: TransformCommentAPIs['addLeadingInlineComments']),
+    }) as TransformCommentAPIs['addLeadingInlineComments'],
 
     addTrailingComments: ((node, comments): void => {
       pushMutation(
@@ -445,7 +451,7 @@ export function getTransformContext(): TransformContextAdditions {
           })),
         ),
       );
-    }: TransformCommentAPIs['addTrailingComments']),
+    }) as TransformCommentAPIs['addTrailingComments'],
 
     addTrailingInlineComments: ((node, comments): void => {
       pushMutation(
@@ -457,13 +463,13 @@ export function getTransformContext(): TransformContextAdditions {
           })),
         ),
       );
-    }: TransformCommentAPIs['addTrailingInlineComments']),
+    }) as TransformCommentAPIs['addTrailingInlineComments'],
 
     removeComments: ((comments): void => {
       toArray(comments).forEach(comment => {
         pushMutation(createRemoveCommentMutation(comment));
       });
-    }: TransformCommentAPIs['removeComments']),
+    }) as TransformCommentAPIs['removeComments'],
   };
   const insertAPIs: TransformInsertAPIs = {
     insertAfterStatement: ((target, nodesToInsert): void => {
@@ -476,7 +482,7 @@ export function getTransformContext(): TransformContextAdditions {
           ),
         ),
       );
-    }: TransformInsertAPIs['insertBeforeStatement']),
+    }) as TransformInsertAPIs['insertBeforeStatement'],
 
     insertBeforeStatement: ((target, nodesToInsert): void => {
       pushMutation(
@@ -488,19 +494,19 @@ export function getTransformContext(): TransformContextAdditions {
           ),
         ),
       );
-    }: TransformInsertAPIs['insertBeforeStatement']),
+    }) as TransformInsertAPIs['insertBeforeStatement'],
   };
   const removeAPIs: TransformRemoveAPIs = {
     removeNode: ((node): void => {
       pushMutation(createRemoveNodeMutation(node));
-    }: TransformRemoveAPIs['removeNode']),
+    }) as TransformRemoveAPIs['removeNode'],
 
     removeStatement: ((node): void => {
       pushMutation(createRemoveStatementMutation(node));
-    }: TransformRemoveAPIs['removeStatement']),
+    }) as TransformRemoveAPIs['removeStatement'],
   };
   const replaceAPIs: TransformReplaceAPIs = {
-    replaceNode: (((
+    replaceNode: ((
       target: ESNode,
       nodeToReplaceWith: MaybeDetachedNode<ESNode>,
       options?: ReplaceNodeOptions,
@@ -512,7 +518,7 @@ export function getTransformContext(): TransformContextAdditions {
           options,
         ),
       );
-    }: $FlowFixMe): TransformReplaceAPIs['replaceNode']),
+    }) as $FlowFixMe as TransformReplaceAPIs['replaceNode'],
 
     replaceStatementWithMany: ((
       target,
@@ -526,10 +532,10 @@ export function getTransformContext(): TransformContextAdditions {
           options,
         ),
       );
-    }: TransformReplaceAPIs['replaceStatementWithMany']),
+    }) as TransformReplaceAPIs['replaceStatementWithMany'],
   };
   const modifyAPIs: TransformModifyAPIs = {
-    modifyNodeInPlace: ((target: ESNode, newProps: $ReadOnly<{...}>): void => {
+    modifyNodeInPlace: ((target: ESNode, newProps: Readonly<{...}>): void => {
       const detachedProps = {};
       for (const [key, value] of Object.entries(newProps)) {
         if (isNode(value)) {
@@ -542,7 +548,7 @@ export function getTransformContext(): TransformContextAdditions {
       }
 
       pushMutation(createModifyNodeInPlaceMutation(target, detachedProps));
-    }: TransformModifyAPIs['modifyNodeInPlace']),
+    }) as TransformModifyAPIs['modifyNodeInPlace'],
   };
 
   return {
@@ -562,9 +568,9 @@ export function getTransformContext(): TransformContextAdditions {
   };
 }
 
-function toArray<T>(thing: SingleOrArray<T>): $ReadOnlyArray<T> {
+function toArray<T>(thing: SingleOrArray<T>): ReadonlyArray<T> {
   if (Array.isArray(thing)) {
-    return (thing: $FlowFixMe);
+    return thing as $FlowFixMe;
   }
   return [thing];
 }

package/dist/transform/comments/comments.js

@@ -36,18 +36,6 @@ var _os = require("os");
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-/**
- * 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
- */
-// $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;
@@ -61,30 +49,18 @@ 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.
+  let code = text;
+  delete program.comments;
 
   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.printed = false;
+      docblockComment.leading = true;
       docblockComment.trailing = false;
-    } // If we have a first node in the program body, attach the comment to that
-    // otherwise set it on the program.
-
+    }
 
     if (program.body.length > 0) {
       const firstStatement = program.body[0];
@@ -94,17 +70,13 @@ function mutateESTreeASTCommentsForPrettier(program, text) {
         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;
@@ -121,40 +93,30 @@ function cloneCommentsToNewNode(oldNode, newNode) {
 
 function cloneJSDocCommentsToNewNode(oldNode, newNode) {
   const comments = getCommentsForNode(oldNode).filter(comment => {
-    return (0, _hermesEstree.isBlockComment)(comment) && // JSDoc comments always start with an extra asterisk
-    comment.value.startsWith('*');
+    return (0, _hermesEstree.isBlockComment)(comment) && comment.value.startsWith('*');
   });
   setCommentsOnNode(newNode, [...getCommentsForNode(newNode), ...comments.map(cloneCommentWithMarkers)]);
 }
 
 function setCommentsOnNode(node, comments) {
-  // $FlowExpectedError[prop-missing] - this property is secretly added by prettier.
-  // $FlowExpectedError[incompatible-use] - this property is secretly added by prettier.
-  // $FlowExpectedError[cannot-write] - this property is secretly added by prettier.
   node.comments = comments;
 }
 
 function getCommentsForNode(node) {
   var _node$comments;
 
-  // $FlowExpectedError[prop-missing] - this property is secretly added by prettier.
-  // $FlowExpectedError[incompatible-use] - this property is secretly added by prettier.
   return (_node$comments = node.comments) != null ? _node$comments : [];
 }
 
 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) {
-  // $FlowExpectedError[prop-missing] - this property is secretly added by prettier.
   return comment.leading === true;
 }
 
 function isTrailingComment(comment) {
-  // $FlowExpectedError[prop-missing] - this property is secretly added by prettier.
   return comment.trailing === true;
 }
 
@@ -185,7 +147,6 @@ function addComment(node, comment, placement) {
 }
 
 function cloneComment(comment) {
-  // $FlowExpectedError[incompatible-type]
   return {
     type: comment.type,
     value: comment.value,
@@ -195,7 +156,6 @@ function cloneComment(comment) {
 }
 
 function cloneCommentWithMarkers(comment) {
-  // $FlowExpectedError[incompatible-type]
   return {
     type: comment.type,
     value: comment.value,
@@ -215,19 +175,13 @@ function getFirstNonWhitespaceIndex(code) {
 }
 
 function makeCommentOwnLine(code, comment) {
-  let newCode = code; // 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 newCode = code;
   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];
   return newCode;
@@ -239,11 +193,6 @@ function appendCommentToSource(code, comment, placement) {
   switch (comment.type) {
     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:
@@ -255,18 +204,13 @@ function appendCommentToSource(code, comment, placement) {
           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;
@@ -278,30 +222,20 @@ function appendCommentToSource(code, comment, placement) {
 
     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 += _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]
-
+        const end = newCode.length;
         comment.range = [start, end];
         break;
       }