hermes-transform 0.5.0 → 0.6.0

package/dist/transform/TransformContext.js.flow

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) Facebook, Inc. and its affiliates.
+ * 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.
@@ -9,9 +9,11 @@
  */
 
 import type {
+  ClassMember,
   Comment,
   ESNode,
   Expression,
+  FunctionParameter,
   ModuleDeclaration,
   Statement,
   TypeAnnotationType,
@@ -24,10 +26,12 @@ import type {AddTrailingCommentsMutation} from './mutations/AddTrailingComments'
 import type {CloneCommentsToMutation} from './mutations/CloneCommentsTo';
 import type {InsertStatementMutation} from './mutations/InsertStatement';
 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 {ReplaceStatementWithManyMutation} from './mutations/ReplaceStatementWithMany';
 
+import {codeFrameColumns} from '@babel/code-frame';
 import {deepCloneNode, shallowCloneNode} from '../detachedNode';
 import {
   getCommentsForNode,
@@ -39,6 +43,7 @@ import {createAddTrailingCommentsMutation} from './mutations/AddTrailingComments
 import {createCloneCommentsToMutation} from './mutations/CloneCommentsTo';
 import {createInsertStatementMutation} from './mutations/InsertStatement';
 import {createRemoveCommentMutation} from './mutations/RemoveComment';
+import {createRemoveNodeMutation} from './mutations/RemoveNode';
 import {createRemoveStatementMutation} from './mutations/RemoveStatement';
 import {createReplaceNodeMutation} from './mutations/ReplaceNode';
 import {createReplaceStatementWithManyMutation} from './mutations/ReplaceStatementWithMany';
@@ -49,6 +54,7 @@ type Mutation = $ReadOnly<
   | CloneCommentsToMutation
   | InsertStatementMutation
   | RemoveCommentMutation
+  | RemoveNodeMutation
   | RemoveStatementMutation
   | ReplaceNodeMutation
   | ReplaceStatementWithManyMutation,
@@ -65,12 +71,10 @@ type ReplaceNodeOptions = $ReadOnly<{
   keepComments?: boolean,
 }>;
 
-export type TransformContext = $ReadOnly<{
-  mutations: $ReadOnlyArray<Mutation>,
-  astWasMutated: boolean,
-
+type TransformCloneAPIs = $ReadOnly<{
   /**
-   * Shallowly clones the given node and applies the given overrides.
+   * Shallowly clones the given node.
+   *
    * !!! Be careful about using this !!!
    * This does not clone children nodes. This means that if you keep
    * the original node in the AST then you will have two trees in the
@@ -84,12 +88,17 @@ export type TransformContext = $ReadOnly<{
    * If you want to literally duplicate a node to place somewhere else
    * in the AST, then use `deepCloneNode` instead.
    */
-  shallowCloneNode: TransformCloneSignatures & {
-    // generic passthrough cases with no options
+  shallowCloneNode: {
     <T: ESNode>(node: T): DetachedNode<T>,
     <T: ESNode>(node: ?T): DetachedNode<T> | null,
   },
 
+  /**
+   * Shallowly clones the given node and applies the given overrides.
+   * {@see shallowCloneNode}
+   */
+  shallowCloneNodeWithOverrides: TransformCloneSignatures,
+
   /**
    * {@see shallowCloneNode}
    */
@@ -99,25 +108,83 @@ export type TransformContext = $ReadOnly<{
   },
 
   /**
-   * Deeply clones the node and all its children, then applies the
-   * given overrides.
+   * Deeply clones the node and all its children.
+   *
    * !!! Be careful about using this !!!
    * Because this is a deep clone, using it high up in the AST can
    * result in a lot of work being done.
    */
-  deepCloneNode: TransformCloneSignatures & {
-    // generic passthrough cases with no options
+  deepCloneNode: {
     <T: ESNode>(node: T): DetachedNode<T>,
     <T: ESNode>(node: ?T): DetachedNode<T> | null,
   },
 
+  /**
+   * Deeply clones the node and all its children, then applies the
+   * given overrides.
+   * {@see deepCloneNode}
+   */
+  deepCloneNodeWithOverrides: TransformCloneSignatures,
+}>;
+
+type TransformCommentAPIs = $ReadOnly<{
+  /**
+   * Gets all of the comments attached to the given node.
+   */
+  getComments: (node: ESNode) => Array<Comment>,
+
+  /**
+   * Gets the leading comments attached to the given node.
+   */
+  getLeadingComments: (node: ESNode) => Array<Comment>,
+
+  /**
+   * Gets the trailing comments attached to the given node.
+   */
+  getTrailingComments: (node: ESNode) => Array<Comment>,
+
+  /**
+   * Clones all of the comments from the target node to the destination node.
+   * As its name suggest - this will clone the comments, duplicating them
+   * entirely. It will not remove the comments from the target node afterward.
+   */
+  cloneCommentsTo: (
+    target: ESNode,
+    destination: ESNode | DetachedNode<ESNode>,
+  ) => void,
+
+  /**
+   * Add leading comments to the specified node.
+   */
+  addLeadingComments: (
+    node: ESNode | DetachedNode<ESNode>,
+    comments: SingleOrArray<Comment>,
+  ) => void,
+
+  /**
+   * Add trailing comments to the specified node.
+   */
+  addTrailingComments: (
+    node: ESNode | DetachedNode<ESNode>,
+    comments: SingleOrArray<Comment>,
+  ) => void,
+
+  /**
+   * Removes the specified comments
+   */
+  removeComments: (comments: SingleOrArray<Comment>) => void,
+}>;
+
+type TransformInsertAPIs = $ReadOnly<{
   /**
    * Insert `nodeToInsert` after the `target` statement.
    * The inserted nodes will be kept in the order given.
    */
   insertAfterStatement: (
-    target: ModuleDeclaration | Statement,
-    nodeToInsert: SingleOrArray<DetachedNode<ModuleDeclaration | Statement>>,
+    target: InsertStatementMutation['target'],
+    nodeToInsert: SingleOrArray<
+      DetachedNode<InsertStatementMutation['target']>,
+    >,
   ) => void,
 
   /**
@@ -125,39 +192,69 @@ export type TransformContext = $ReadOnly<{
    * The inserted nodes will be kept in the order given.
    */
   insertBeforeStatement: (
-    target: ModuleDeclaration | Statement,
-    nodeToInsert: SingleOrArray<DetachedNode<ModuleDeclaration | Statement>>,
+    target: InsertStatementMutation['target'],
+    nodeToInsert: SingleOrArray<
+      DetachedNode<InsertStatementMutation['target']>,
+    >,
   ) => void,
+}>;
 
+type TransformRemoveAPIs = $ReadOnly<{
+  /**
+   * Removes a given node from the AST.
+   * The set of thigns that can be removed is intentionally restricted by types.
+   * This represents the set of "misc nodes" that are known to be safe to remove without outright breaking the AST.
+   */
+  removeNode: (node: RemoveNodeMutation['node']) => void,
+
+  /**
+   * Removes a given statement from the AST.
+   */
+  removeStatement: (node: RemoveStatementMutation['node']) => void,
+}>;
+
+type TransformReplaceAPIs = $ReadOnly<{
   /**
    * Replace the `target` node with the `nodeToReplaceWith` node.
    * This simply does an in-place replacement in the AST.
    */
   replaceNode: {
-    // expressions must be replaced with other expressions
+    // Expressions may be replaced with other expressions
     (
       target: Expression,
       nodeToReplaceWith: DetachedNode<Expression>,
       options?: ReplaceNodeOptions,
     ): void,
-    // module declarations must be replaced with statements or other module declarations
+    // Module declarations may be replaced with statements or other module declarations
     (
       target: ModuleDeclaration,
       nodeToReplaceWith: DetachedNode<ModuleDeclaration | Statement>,
       options?: ReplaceNodeOptions,
     ): void,
-    // Statement must be replaced with statements or module declarations
+    // Statement maybe be replaced with statements or module declarations
     (
       target: Statement,
       nodeToReplaceWith: DetachedNode<ModuleDeclaration | Statement>,
       options?: ReplaceNodeOptions,
     ): void,
-    // Types must be replaced with types
+    // Types maybe be replaced with other types
     (
       target: TypeAnnotationType,
       nodeToReplaceWith: DetachedNode<TypeAnnotationType>,
       options?: ReplaceNodeOptions,
     ): void,
+    // Class members may be replaced with other class members
+    (
+      target: ClassMember,
+      nodeToReplaceWith: DetachedNode<ClassMember>,
+      options?: ReplaceNodeOptions,
+    ): void,
+    // Function params amy be replace with other function params
+    (
+      target: FunctionParameter,
+      nodeToReplaceWith: DetachedNode<FunctionParameter>,
+      options?: ReplaceNodeOptions,
+    ): void,
   } & TransformReplaceSignatures, // allow like-for-like replacements as well
 
   /**
@@ -165,10 +262,8 @@ export type TransformContext = $ReadOnly<{
    * The nodes will be kept in the order given.
    */
   replaceStatementWithMany: (
-    target: ModuleDeclaration | Statement,
-    nodesToReplaceWith: $ReadOnlyArray<
-      DetachedNode<ModuleDeclaration | Statement>,
-    >,
+    target: ReplaceStatementWithManyMutation['target'],
+    nodesToReplaceWith: ReplaceStatementWithManyMutation['nodesToReplaceWith'],
     options?: {
       /**
        * Moves the comments from the target node to the first node in the array.
@@ -178,64 +273,45 @@ export type TransformContext = $ReadOnly<{
       keepComments?: boolean,
     },
   ) => void,
+}>;
 
-  /**
-   * Removes a given node from the AST.
-   */
-  removeStatement: (node: ModuleDeclaration | Statement) => void,
-
-  //
-  // Comment APIs
-  //
-
-  /**
-   * Gets all of the comments attached to the given node.
-   */
-  getComments: (node: ESNode) => Array<Comment>,
-
-  /**
-   * Gets the leading comments attached to the given node.
-   */
-  getLeadingComments: (node: ESNode) => Array<Comment>,
-
-  /**
-   * Gets the trailing comments attached to the given node.
-   */
-  getTrailingComments: (node: ESNode) => Array<Comment>,
-
-  /**
-   * Clones all of the comments from the target node to the destination node.
-   * As its name suggest - this will clone the comments, duplicating them
-   * entirely. It will not remove the comments from the target node afterward.
-   */
-  cloneCommentsTo: (
-    target: ESNode,
-    destination: ESNode | DetachedNode<ESNode>,
-  ) => void,
+export type TransformContext = $ReadOnly<{
+  mutations: $ReadOnlyArray<Mutation>,
+  astWasMutated: boolean,
 
   /**
-   * Add leading comments to the specified node.
+   * Creates a full code frame for the node along with the message.
+   *
+   * i.e. `context.buildCodeFrame(node, 'foo')` will create a string like:
+   * ```
+   * 56 | function () {
+   *    | ^^^^^^^^^^^^^
+   * 57 | }.bind(this)
+   *    | ^^ foo
+   * ```
    */
-  addLeadingComments: (
-    node: ESNode | DetachedNode<ESNode>,
-    comments: SingleOrArray<Comment>,
-  ) => void,
+  buildCodeFrame: (node: ESNode, message: string) => string,
 
   /**
-   * Add trailing comments to the specified node.
+   * Creates a simple code frame for the node along with the message.
+   * Use this if you want a condensed marker for your message.
+   *
+   * i.e. `context.logWithNode(node, 'foo')` will create a string like:
+   * ```
+   * [FunctionExpression:56:44] foo
+   * ```
+   * (where 56:44 represents L56, Col44)
    */
-  addTrailingComments: (
-    node: ESNode | DetachedNode<ESNode>,
-    comments: SingleOrArray<Comment>,
-  ) => void,
+  buildSimpleCodeFrame: (node: ESNode, message: string) => string,
 
-  /**
-   * Removes the specified comments
-   */
-  removeComments: (comments: SingleOrArray<Comment>) => void,
+  ...TransformCommentAPIs,
+  ...TransformCloneAPIs,
+  ...TransformInsertAPIs,
+  ...TransformRemoveAPIs,
+  ...TransformReplaceAPIs,
 }>;
 
-export function getTransformContext(): TransformContext {
+export function getTransformContext(code: string): TransformContext {
   /**
    * The mutations in order of collection.
    */
@@ -246,27 +322,31 @@ export function getTransformContext(): TransformContext {
     }
   }
 
-  return {
-    mutations,
+  const cloneAPIs: TransformCloneAPIs = {
+    // $FlowExpectedError[incompatible-exact]
+    shallowCloneNode: ((
+      node: ?ESNode,
+    ): // $FlowExpectedError[incompatible-cast]
+    ?DetachedNode<ESNode> => {
+      if (node == null) {
+        return null;
+      }
 
-    // $FlowExpectedError[unsafe-getters-setters]
-    get astWasMutated(): boolean {
-      return mutations.length > 0;
-    },
+      return shallowCloneNode(node);
+    }: TransformCloneAPIs['shallowCloneNode']),
 
     // $FlowExpectedError[incompatible-exact]
-    shallowCloneNode: ((
+    shallowCloneNodeWithOverrides: ((
       node: ?ESNode,
       newProps?: $ReadOnly<{...}>,
     ): // $FlowExpectedError[incompatible-cast]
-    // $FlowExpectedError[prop-missing]
     ?DetachedNode<ESNode> => {
       if (node == null) {
         return null;
       }
 
       return shallowCloneNode(node, newProps);
-    }: TransformContext['shallowCloneNode']),
+    }: TransformCloneAPIs['shallowCloneNodeWithOverrides']),
 
     shallowCloneArray: (<T: ESNode>(
       nodes: ?$ReadOnlyArray<T>,
@@ -277,34 +357,87 @@ export function getTransformContext(): TransformContext {
       }
 
       return nodes.map(node => shallowCloneNode<T>(node));
-    }: TransformContext['shallowCloneArray']),
+    }: TransformCloneAPIs['shallowCloneArray']),
 
     // $FlowExpectedError[incompatible-exact]
     deepCloneNode: ((
       node: ?ESNode,
+    ): // $FlowExpectedError[incompatible-cast]
+    ?DetachedNode<ESNode> => {
+      if (node == null) {
+        return null;
+      }
+
+      return deepCloneNode(node);
+    }: TransformCloneAPIs['deepCloneNode']),
+
+    // $FlowExpectedError[incompatible-exact]
+    deepCloneNodeWithOverrides: ((
+      node: ?ESNode,
       newProps?: $ReadOnly<{...}>,
     ): // $FlowExpectedError[incompatible-cast]
-    // $FlowExpectedError[prop-missing]
     ?DetachedNode<ESNode> => {
       if (node == null) {
         return null;
       }
 
       return deepCloneNode(node, newProps);
-    }: TransformContext['deepCloneNode']),
+    }: TransformCloneAPIs['deepCloneNodeWithOverrides']),
+  };
+  const commentAPIs: TransformCommentAPIs = {
+    getComments: ((node): Array<Comment> => {
+      return [...getCommentsForNode(node)];
+    }: TransformCommentAPIs['getComments']),
+
+    getLeadingComments: ((node): Array<Comment> => {
+      return getCommentsForNode(node).filter(isLeadingComment);
+    }: TransformCommentAPIs['getLeadingComments']),
+
+    getTrailingComments: ((node): Array<Comment> => {
+      return getCommentsForNode(node).filter(isTrailingComment);
+    }: TransformCommentAPIs['getTrailingComments']),
+
+    cloneCommentsTo: ((target, destination): void => {
+      pushMutation(createCloneCommentsToMutation(target, destination));
+    }: TransformCommentAPIs['cloneCommentsTo']),
 
+    addLeadingComments: ((node, comments): void => {
+      pushMutation(createAddLeadingCommentsMutation(node, toArray(comments)));
+    }: TransformCommentAPIs['addLeadingComments']),
+
+    addTrailingComments: ((node, comments): void => {
+      pushMutation(createAddTrailingCommentsMutation(node, toArray(comments)));
+    }: TransformCommentAPIs['addTrailingComments']),
+
+    removeComments: ((comments): void => {
+      toArray(comments).forEach(comment => {
+        pushMutation(createRemoveCommentMutation(comment));
+      });
+    }: TransformCommentAPIs['removeComments']),
+  };
+  const insertAPIs: TransformInsertAPIs = {
     insertAfterStatement: ((target, nodesToInsert): void => {
       pushMutation(
         createInsertStatementMutation('after', target, toArray(nodesToInsert)),
       );
-    }: TransformContext['insertBeforeStatement']),
+    }: TransformInsertAPIs['insertBeforeStatement']),
 
     insertBeforeStatement: ((target, nodesToInsert): void => {
       pushMutation(
         createInsertStatementMutation('before', target, toArray(nodesToInsert)),
       );
-    }: TransformContext['insertBeforeStatement']),
+    }: TransformInsertAPIs['insertBeforeStatement']),
+  };
+  const removeAPIs: TransformRemoveAPIs = {
+    removeNode: ((node): void => {
+      pushMutation(createRemoveNodeMutation(node));
+    }: TransformRemoveAPIs['removeNode']),
 
+    removeStatement: ((node): void => {
+      pushMutation(createRemoveStatementMutation(node));
+    }: TransformRemoveAPIs['removeStatement']),
+  };
+  const replaceAPIs: TransformReplaceAPIs = {
     replaceNode: ((
       target: ESNode,
       nodeToReplaceWith: DetachedNode<ESNode>,
@@ -313,7 +446,7 @@ export function getTransformContext(): TransformContext {
       pushMutation(
         createReplaceNodeMutation(target, nodeToReplaceWith, options),
       );
-    }: TransformContext['replaceNode']),
+    }: TransformReplaceAPIs['replaceNode']),
 
     replaceStatementWithMany: ((
       target,
@@ -327,45 +460,46 @@ export function getTransformContext(): TransformContext {
           options,
         ),
       );
-    }: TransformContext['replaceStatementWithMany']),
-
-    removeStatement: ((node): void => {
-      pushMutation(createRemoveStatementMutation(node));
-    }: TransformContext['removeStatement']),
-
-    //
-    // Comment APIs
-    //
-
-    getComments: ((node): Array<Comment> => {
-      return [...getCommentsForNode(node)];
-    }: TransformContext['getComments']),
-
-    getLeadingComments: ((node): Array<Comment> => {
-      return getCommentsForNode(node).filter(isLeadingComment);
-    }: TransformContext['getLeadingComments']),
+    }: TransformReplaceAPIs['replaceStatementWithMany']),
+  };
 
-    getTrailingComments: ((node): Array<Comment> => {
-      return getCommentsForNode(node).filter(isTrailingComment);
-    }: TransformContext['getTrailingComments']),
+  return {
+    mutations,
 
-    cloneCommentsTo: ((target, destination): void => {
-      pushMutation(createCloneCommentsToMutation(target, destination));
-    }: TransformContext['cloneCommentsTo']),
+    // $FlowExpectedError[unsafe-getters-setters]
+    get astWasMutated(): boolean {
+      return mutations.length > 0;
+    },
 
-    addLeadingComments: ((node, comments): void => {
-      pushMutation(createAddLeadingCommentsMutation(node, toArray(comments)));
-    }: TransformContext['addLeadingComments']),
+    buildCodeFrame: (node: ESNode, message: string): string => {
+      // babel uses 1-indexed columns
+      const locForBabel = {
+        start: {
+          line: node.loc.start.line,
+          column: node.loc.start.column + 1,
+        },
+        end: {
+          line: node.loc.end.line,
+          column: node.loc.end.column + 1,
+        },
+      };
+      return codeFrameColumns(code, locForBabel, {
+        linesAbove: 0,
+        linesBelow: 0,
+        highlightCode: process.env.NODE_ENV !== 'test',
+        message: message,
+      });
+    },
 
-    addTrailingComments: ((node, comments): void => {
-      pushMutation(createAddTrailingCommentsMutation(node, toArray(comments)));
-    }: TransformContext['addTrailingComments']),
+    buildSimpleCodeFrame: (node: ESNode, message: string): string => {
+      return `[${node.type}:${node.loc.start.line}:${node.loc.start.column}] ${message}`;
+    },
 
-    removeComments: ((comments): void => {
-      toArray(comments).forEach(comment => {
-        pushMutation(createRemoveCommentMutation(comment));
-      });
-    }: TransformContext['removeComments']),
+    ...cloneAPIs,
+    ...commentAPIs,
+    ...insertAPIs,
+    ...removeAPIs,
+    ...replaceAPIs,
   };
 }
 

package/dist/transform/comments/comments.js

@@ -24,25 +24,25 @@ var _printerEstree = _interopRequireDefault(require("./prettier/language-js/prin
 
 var _util = require("./prettier/common/util");
 
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
-
-function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
-
-function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
-
-function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-
-function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
-
-function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
-
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
-
+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]
 function attachComments(comments, ast, text) {
   (0, _comments.attach)(comments, ast, text, {
     locStart: _loc.locStart,
     locEnd: _loc.locEnd,
-    printer: _printerEstree["default"]
+    printer: _printerEstree.default
   });
 }
 
@@ -57,19 +57,19 @@ function setCommentsOnNode(node, comments) {
 }
 
 function addCommentsToNode(node, comments) {
-  var _node$comments, _ref;
+  var _node$comments;
 
   // $FlowExpectedError - this property is secretly added by prettier.
-  node.comments = (_node$comments = node.comments) !== null && _node$comments !== void 0 ? _node$comments : []; // $FlowExpectedError
+  node.comments = (_node$comments = node.comments) != null ? _node$comments : []; // $FlowExpectedError
 
-  (_ref = node.comments).push.apply(_ref, _toConsumableArray(comments));
+  node.comments.push(...comments);
 }
 
 function getCommentsForNode(node) {
   var _node$comments2;
 
   // $FlowExpectedError - this property is secretly added by prettier.
-  return (_node$comments2 = node.comments) !== null && _node$comments2 !== void 0 ? _node$comments2 : [];
+  return (_node$comments2 = node.comments) != null ? _node$comments2 : [];
 }
 
 function isLeadingComment(comment) {
@@ -117,23 +117,23 @@ function appendCommentToSource(code, comment) {
   // 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
-  var commentText = comment.value;
+  let commentText = comment.value;
 
   switch (comment.type) {
     case 'Block':
-      commentText = "/*".concat(commentText, "*/");
+      commentText = `/*${commentText}*/`;
       break;
 
     case 'Line':
-      commentText = "//".concat(commentText);
+      commentText = `//${commentText}`;
       break;
   }
 
-  var newCode = code;
+  let newCode = code;
   newCode += '\n';
-  var start = newCode.length;
+  const start = newCode.length;
   newCode += commentText;
-  var end = newCode.length; // $FlowExpectedError[cannot-write]
+  const end = newCode.length; // $FlowExpectedError[cannot-write]
 
   comment.range = [start, end];
   return newCode;

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

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) Facebook, Inc. and its affiliates.
+ * 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.