hermes-transform 0.6.0 → 0.7.0

package/dist/index.js.flow

@@ -10,8 +10,9 @@
 
 'use strict';
 
-export type {TraversalContext, Visitor} from './traverse/traverse';
+export type {TraversalContextBase, Visitor} from './traverse/traverse';
 export type {TransformVisitor} from './transform/transform';
+export type {TransformContext} from './transform/TransformContext';
 export type {DetachedNode} from './detachedNode';
 
 export {SimpleTraverser} from './traverse/SimpleTraverser';

package/dist/transform/MutationContext.js

@@ -72,8 +72,8 @@ class MutationContext {
     }
   }
 
-  appendCommentToSource(comment) {
-    this.code = (0, _comments.appendCommentToSource)(this.code, comment);
+  appendCommentToSource(comment, placement) {
+    this.code = (0, _comments.appendCommentToSource)(this.code, comment, placement);
   }
 
 }

package/dist/transform/MutationContext.js.flow

@@ -8,6 +8,7 @@
  * @format
  */
 
+import type {CommentPlacement} from './comments/comments';
 import type {Comment, ESNode} from 'hermes-estree';
 
 import {NodeIsDeletedError, NodeIsMutatedError} from './Errors';
@@ -74,7 +75,7 @@ export class MutationContext {
     }
   }
 
-  appendCommentToSource(comment: Comment): void {
-    this.code = appendCommentToSource(this.code, comment);
+  appendCommentToSource(comment: Comment, placement: CommentPlacement): void {
+    this.code = appendCommentToSource(this.code, comment, placement);
   }
 }

package/dist/transform/TransformContext.js

@@ -5,15 +5,11 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.getTransformContext = getTransformContext;
 
-var _codeFrame = require("@babel/code-frame");
-
 var _detachedNode = require("../detachedNode");
 
 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");
 
@@ -38,7 +34,7 @@ var _ReplaceStatementWithMany = require("./mutations/ReplaceStatementWithMany");
  * 
  * @format
  */
-function getTransformContext(code) {
+function getTransformContext() {
   /**
    * The mutations in order of collection.
    */
@@ -51,7 +47,6 @@ function getTransformContext(code) {
   }
 
   const cloneAPIs = {
-    // $FlowExpectedError[incompatible-exact]
     shallowCloneNode: node => {
       if (node == null) {
         return null;
@@ -74,7 +69,6 @@ function getTransformContext(code) {
 
       return nodes.map(node => (0, _detachedNode.shallowCloneNode)(node));
     },
-    // $FlowExpectedError[incompatible-exact]
     deepCloneNode: node => {
       if (node == null) {
         return null;
@@ -105,10 +99,28 @@ function getTransformContext(code) {
       pushMutation((0, _CloneCommentsTo.createCloneCommentsToMutation)(target, destination));
     },
     addLeadingComments: (node, comments) => {
-      pushMutation((0, _AddLeadingComments.createAddLeadingCommentsMutation)(node, toArray(comments)));
+      pushMutation((0, _AddComments.createAddCommentsMutation)(node, toArray(comments).map(comment => ({
+        comment,
+        placement: _comments.CommentPlacement.LEADING_OWN_LINE
+      }))));
+    },
+    addLeadingInlineComments: (node, comments) => {
+      pushMutation((0, _AddComments.createAddCommentsMutation)(node, toArray(comments).map(comment => ({
+        comment,
+        placement: _comments.CommentPlacement.LEADING_INLINE
+      }))));
     },
     addTrailingComments: (node, comments) => {
-      pushMutation((0, _AddTrailingComments.createAddTrailingCommentsMutation)(node, toArray(comments)));
+      pushMutation((0, _AddComments.createAddCommentsMutation)(node, toArray(comments).map(comment => ({
+        comment,
+        placement: _comments.CommentPlacement.TRAILING_OWN_LINE
+      }))));
+    },
+    addTrailingInlineComments: (node, comments) => {
+      pushMutation((0, _AddComments.createAddCommentsMutation)(node, toArray(comments).map(comment => ({
+        comment,
+        placement: _comments.CommentPlacement.TRAILING_INLINE
+      }))));
     },
     removeComments: comments => {
       toArray(comments).forEach(comment => {
@@ -148,28 +160,6 @@ function getTransformContext(code) {
       return mutations.length > 0;
     },
 
-    buildCodeFrame: (node, message) => {
-      // 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 (0, _codeFrame.codeFrameColumns)(code, locForBabel, {
-        linesAbove: 0,
-        linesBelow: 0,
-        highlightCode: process.env.NODE_ENV !== 'test',
-        message: message
-      });
-    },
-    buildSimpleCodeFrame: (node, message) => {
-      return `[${node.type}:${node.loc.start.line}:${node.loc.start.column}] ${message}`;
-    },
     ...cloneAPIs,
     ...commentAPIs,
     ...insertAPIs,

package/dist/transform/TransformContext.js.flow

@@ -21,8 +21,8 @@ import type {
 import type {DetachedNode} from '../detachedNode';
 import type {TransformCloneSignatures} from '../generated/TransformCloneSignatures';
 import type {TransformReplaceSignatures} from '../generated/TransformReplaceSignatures';
-import type {AddLeadingCommentsMutation} from './mutations/AddLeadingComments';
-import type {AddTrailingCommentsMutation} from './mutations/AddTrailingComments';
+import type {TraversalContext} from '../traverse/traverse';
+import type {AddCommentsMutation} from './mutations/AddComments';
 import type {CloneCommentsToMutation} from './mutations/CloneCommentsTo';
 import type {InsertStatementMutation} from './mutations/InsertStatement';
 import type {RemoveCommentMutation} from './mutations/RemoveComment';
@@ -31,15 +31,14 @@ 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 {
+  CommentPlacement,
   getCommentsForNode,
   isLeadingComment,
   isTrailingComment,
 } from './comments/comments';
-import {createAddLeadingCommentsMutation} from './mutations/AddLeadingComments';
-import {createAddTrailingCommentsMutation} from './mutations/AddTrailingComments';
+import {createAddCommentsMutation} from './mutations/AddComments';
 import {createCloneCommentsToMutation} from './mutations/CloneCommentsTo';
 import {createInsertStatementMutation} from './mutations/InsertStatement';
 import {createRemoveCommentMutation} from './mutations/RemoveComment';
@@ -49,8 +48,7 @@ import {createReplaceNodeMutation} from './mutations/ReplaceNode';
 import {createReplaceStatementWithManyMutation} from './mutations/ReplaceStatementWithMany';
 
 type Mutation = $ReadOnly<
-  | AddLeadingCommentsMutation
-  | AddTrailingCommentsMutation
+  | AddCommentsMutation
   | CloneCommentsToMutation
   | InsertStatementMutation
   | RemoveCommentMutation
@@ -154,7 +152,7 @@ type TransformCommentAPIs = $ReadOnly<{
   ) => void,
 
   /**
-   * Add leading comments to the specified node.
+   * Add comments on the line before a specified node.
    */
   addLeadingComments: (
     node: ESNode | DetachedNode<ESNode>,
@@ -162,13 +160,29 @@ type TransformCommentAPIs = $ReadOnly<{
   ) => void,
 
   /**
-   * Add trailing comments to the specified node.
+   * Add comments inline before a specified node.
+   */
+  addLeadingInlineComments: (
+    node: ESNode | DetachedNode<ESNode>,
+    comments: SingleOrArray<Comment>,
+  ) => void,
+
+  /**
+   * Add comments on the line after a specified node.
    */
   addTrailingComments: (
     node: ESNode | DetachedNode<ESNode>,
     comments: SingleOrArray<Comment>,
   ) => void,
 
+  /**
+   * Add comments inline after a specified node.
+   */
+  addTrailingInlineComments: (
+    node: ESNode | DetachedNode<ESNode>,
+    comments: SingleOrArray<Comment>,
+  ) => void,
+
   /**
    * Removes the specified comments
    */
@@ -275,43 +289,19 @@ type TransformReplaceAPIs = $ReadOnly<{
   ) => void,
 }>;
 
-export type TransformContext = $ReadOnly<{
+export type TransformContextAdditions = $ReadOnly<{
   mutations: $ReadOnlyArray<Mutation>,
   astWasMutated: boolean,
 
-  /**
-   * 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
-   * ```
-   */
-  buildCodeFrame: (node: ESNode, message: string) => string,
-
-  /**
-   * 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)
-   */
-  buildSimpleCodeFrame: (node: ESNode, message: string) => string,
-
   ...TransformCommentAPIs,
   ...TransformCloneAPIs,
   ...TransformInsertAPIs,
   ...TransformRemoveAPIs,
   ...TransformReplaceAPIs,
 }>;
+export type TransformContext = TraversalContext<TransformContextAdditions>;
 
-export function getTransformContext(code: string): TransformContext {
+export function getTransformContext(): TransformContextAdditions {
   /**
    * The mutations in order of collection.
    */
@@ -323,7 +313,6 @@ export function getTransformContext(code: string): TransformContext {
   }
 
   const cloneAPIs: TransformCloneAPIs = {
-    // $FlowExpectedError[incompatible-exact]
     shallowCloneNode: ((
       node: ?ESNode,
     ): // $FlowExpectedError[incompatible-cast]
@@ -339,8 +328,7 @@ export function getTransformContext(code: string): TransformContext {
     shallowCloneNodeWithOverrides: ((
       node: ?ESNode,
       newProps?: $ReadOnly<{...}>,
-    ): // $FlowExpectedError[incompatible-cast]
-    ?DetachedNode<ESNode> => {
+    ): ?DetachedNode<ESNode> => {
       if (node == null) {
         return null;
       }
@@ -359,7 +347,6 @@ export function getTransformContext(code: string): TransformContext {
       return nodes.map(node => shallowCloneNode<T>(node));
     }: TransformCloneAPIs['shallowCloneArray']),
 
-    // $FlowExpectedError[incompatible-exact]
     deepCloneNode: ((
       node: ?ESNode,
     ): // $FlowExpectedError[incompatible-cast]
@@ -375,8 +362,7 @@ export function getTransformContext(code: string): TransformContext {
     deepCloneNodeWithOverrides: ((
       node: ?ESNode,
       newProps?: $ReadOnly<{...}>,
-    ): // $FlowExpectedError[incompatible-cast]
-    ?DetachedNode<ESNode> => {
+    ): ?DetachedNode<ESNode> => {
       if (node == null) {
         return null;
       }
@@ -402,13 +388,53 @@ export function getTransformContext(code: string): TransformContext {
     }: TransformCommentAPIs['cloneCommentsTo']),
 
     addLeadingComments: ((node, comments): void => {
-      pushMutation(createAddLeadingCommentsMutation(node, toArray(comments)));
+      pushMutation(
+        createAddCommentsMutation(
+          node,
+          toArray(comments).map(comment => ({
+            comment,
+            placement: CommentPlacement.LEADING_OWN_LINE,
+          })),
+        ),
+      );
     }: TransformCommentAPIs['addLeadingComments']),
 
+    addLeadingInlineComments: ((node, comments): void => {
+      pushMutation(
+        createAddCommentsMutation(
+          node,
+          toArray(comments).map(comment => ({
+            comment,
+            placement: CommentPlacement.LEADING_INLINE,
+          })),
+        ),
+      );
+    }: TransformCommentAPIs['addLeadingInlineComments']),
+
     addTrailingComments: ((node, comments): void => {
-      pushMutation(createAddTrailingCommentsMutation(node, toArray(comments)));
+      pushMutation(
+        createAddCommentsMutation(
+          node,
+          toArray(comments).map(comment => ({
+            comment,
+            placement: CommentPlacement.TRAILING_OWN_LINE,
+          })),
+        ),
+      );
     }: TransformCommentAPIs['addTrailingComments']),
 
+    addTrailingInlineComments: ((node, comments): void => {
+      pushMutation(
+        createAddCommentsMutation(
+          node,
+          toArray(comments).map(comment => ({
+            comment,
+            placement: CommentPlacement.TRAILING_INLINE,
+          })),
+        ),
+      );
+    }: TransformCommentAPIs['addTrailingInlineComments']),
+
     removeComments: ((comments): void => {
       toArray(comments).forEach(comment => {
         pushMutation(createRemoveCommentMutation(comment));
@@ -441,7 +467,7 @@ export function getTransformContext(code: string): TransformContext {
     replaceNode: ((
       target: ESNode,
       nodeToReplaceWith: DetachedNode<ESNode>,
-      options?: $ReadOnly<{keepComments?: boolean}>,
+      options?: ReplaceNodeOptions,
     ): void => {
       pushMutation(
         createReplaceNodeMutation(target, nodeToReplaceWith, options),
@@ -451,7 +477,7 @@ export function getTransformContext(code: string): TransformContext {
     replaceStatementWithMany: ((
       target,
       nodesToReplaceWith,
-      options?: $ReadOnly<{keepComments?: boolean}>,
+      options?: ReplaceNodeOptions,
     ): void => {
       pushMutation(
         createReplaceStatementWithManyMutation(
@@ -471,30 +497,6 @@ export function getTransformContext(code: string): TransformContext {
       return mutations.length > 0;
     },
 
-    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,
-      });
-    },
-
-    buildSimpleCodeFrame: (node: ESNode, message: string): string => {
-      return `[${node.type}:${node.loc.start.line}:${node.loc.start.column}] ${message}`;
-    },
-
     ...cloneAPIs,
     ...commentAPIs,
     ...insertAPIs,

package/dist/transform/comments/comments.js

@@ -3,9 +3,9 @@
 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;
@@ -24,6 +24,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 +40,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,
@@ -82,12 +88,22 @@ function isTrailingComment(comment) {
   return comment.trailing === true;
 }
 
-function addLeadingComment(node, comment) {
-  (0, _util.addLeadingComment)(node, comment);
-}
-
-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 +128,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;
 }