hermes-transform 0.36.1 → 0.37.0

package/dist/src/transform/comments/prettier/common/util.js

@@ -1,11 +1,3 @@
-/**
- * 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
- */
 'use strict';
 
 const stringWidth = require('string-width');
@@ -13,21 +5,10 @@ const stringWidth = require('string-width');
 const getLast = require('../utils/get-last.js');
 
 const notAsciiRegex = /[^\x20-\x7F]/;
-/**
- * @typedef {{backwards?: boolean}} SkipOptions
- */
-
-/**
- * @param {string | RegExp} chars
- * @returns {(text: string, index: number | false, opts?: SkipOptions) => number | false}
- */
 
 function skip(chars) {
   return (text, index, opts) => {
-    const backwards = opts && opts.backwards; // Allow `skip` functions to be threaded together without having
-    // to check for failures (did someone say monads?).
-
-    /* istanbul ignore next */
+    const backwards = opts && opts.backwards;
 
     if (index === false) {
       return false;
@@ -53,45 +34,19 @@ function skip(chars) {
     }
 
     if (cursor === -1 || cursor === length) {
-      // If we reached the beginning or end of the file, return the
-      // out-of-bounds cursor. It's up to the caller to handle this
-      // correctly. We don't want to indicate `false` though if it
-      // actually skipped valid characters.
       return cursor;
     }
 
     return false;
   };
 }
-/**
- * @type {(text: string, index: number | false, opts?: SkipOptions) => number | false}
- */
-
 
 const skipWhitespace = skip(/\s/);
-/**
- * @type {(text: string, index: number | false, opts?: SkipOptions) => number | false}
- */
-
 const skipSpaces = skip(' \t');
-/**
- * @type {(text: string, index: number | false, opts?: SkipOptions) => number | false}
- */
-
 const skipToLineEnd = skip(',; \t');
-/**
- * @type {(text: string, index: number | false, opts?: SkipOptions) => number | false}
- */
-
 const skipEverythingButNewLine = skip(/[^\n\r]/);
-/**
- * @param {string} text
- * @param {number | false} index
- * @returns {number | false}
- */
 
 function skipInlineComment(text, index) {
-  /* istanbul ignore next */
   if (index === false) {
     return false;
   }
@@ -106,15 +61,8 @@ function skipInlineComment(text, index) {
 
   return index;
 }
-/**
- * @param {string} text
- * @param {number | false} index
- * @returns {number | false}
- */
-
 
 function skipTrailingComment(text, index) {
-  /* istanbul ignore next */
   if (index === false) {
     return false;
   }
@@ -124,17 +72,7 @@ function skipTrailingComment(text, index) {
   }
 
   return index;
-} // This one doesn't use the above helper function because it wants to
-// test \r\n in order and `skip` doesn't support ordering and we only
-// want to skip one newline. It's simple to implement.
-
-/**
- * @param {string} text
- * @param {number | false} index
- * @param {SkipOptions=} opts
- * @returns {number | false}
- */
-
+}
 
 function skipNewline(text, index, opts) {
   const backwards = opts && opts.backwards;
@@ -146,9 +84,6 @@ function skipNewline(text, index, opts) {
   const atIndex = text.charAt(index);
 
   if (backwards) {
-    // We already replace `\r\n` with `\n` before parsing
-
-    /* istanbul ignore next */
     if (text.charAt(index - 1) === '\r' && atIndex === '\n') {
       return index - 2;
     }
@@ -157,9 +92,6 @@ function skipNewline(text, index, opts) {
       return index - 1;
     }
   } else {
-    // We already replace `\r\n` with `\n` before parsing
-
-    /* istanbul ignore next */
     if (atIndex === '\r' && text.charAt(index + 1) === '\n') {
       return index + 2;
     }
@@ -171,26 +103,12 @@ function skipNewline(text, index, opts) {
 
   return index;
 }
-/**
- * @param {string} text
- * @param {number} index
- * @param {SkipOptions=} opts
- * @returns {boolean}
- */
-
 
 function hasNewline(text, index, opts = {}) {
   const idx = skipSpaces(text, opts.backwards ? index - 1 : index, opts);
   const idx2 = skipNewline(text, idx, opts);
   return idx !== idx2;
 }
-/**
- * @param {string} text
- * @param {number} start
- * @param {number} end
- * @returns {boolean}
- */
-
 
 function hasNewlineInRange(text, start, end) {
   for (let i = start; i < end; ++i) {
@@ -201,22 +119,12 @@ function hasNewlineInRange(text, start, end) {
 
   return false;
 }
-/**
- * @param {string} text
- * @param {number} index
- * @returns {boolean}
- */
-
 
 function isNextLineEmptyAfterIndex(text, index) {
-  /** @type {number | false} */
   let oldIdx = null;
-  /** @type {number | false} */
-
   let idx = index;
 
   while (idx !== oldIdx) {
-    // We need to skip all the potential trailing inline comments
     oldIdx = idx;
     idx = skipToLineEnd(text, idx);
     idx = skipInlineComment(text, idx);
@@ -227,18 +135,9 @@ function isNextLineEmptyAfterIndex(text, index) {
   idx = skipNewline(text, idx);
   return idx !== false && hasNewline(text, idx);
 }
-/**
- * @param {string} text
- * @param {number} idx
- * @returns {number | false}
- */
-
 
 function getNextNonSpaceNonCommentCharacterIndexWithStartIndex(text, idx) {
-  /** @type {number | false} */
   let oldIdx = null;
-  /** @type {number | false} */
-
   let nextIdx = idx;
 
   while (nextIdx !== oldIdx) {
@@ -251,42 +150,19 @@ function getNextNonSpaceNonCommentCharacterIndexWithStartIndex(text, idx) {
 
   return nextIdx;
 }
-/**
- * @template N
- * @param {string} text
- * @param {N} node
- * @param {(node: N) => number} locEnd
- * @returns {number | false}
- */
-
 
 function getNextNonSpaceNonCommentCharacterIndex(text, node, locEnd) {
   return getNextNonSpaceNonCommentCharacterIndexWithStartIndex(text, locEnd(node));
 }
-/**
- * @template N
- * @param {string} text
- * @param {N} node
- * @param {(node: N) => number} locEnd
- * @returns {string}
- */
-
 
 function getNextNonSpaceNonCommentCharacter(text, node, locEnd) {
-  return text.charAt( // @ts-expect-error => TBD: can return false, should we define a fallback?
-  getNextNonSpaceNonCommentCharacterIndex(text, node, locEnd));
+  return text.charAt(getNextNonSpaceNonCommentCharacterIndex(text, node, locEnd));
 }
-/**
- * @param {string} text
- * @returns {number}
- */
-
 
 function getStringWidth(text) {
   if (!text) {
     return 0;
-  } // shortcut to avoid needless string `RegExp`s, replacements, and allocations within `string-width`
-
+  }
 
   if (!notAsciiRegex.test(text)) {
     return text.length;
@@ -324,11 +200,6 @@ function addTrailingComment(node, comment) {
   comment.trailing = true;
   addCommentHelper(node, comment);
 }
-/**
- * @param {any} object
- * @returns {object is Array<any>}
- */
-
 
 function isNonEmptyArray(object) {
   return Array.isArray(object) && object.length > 0;

package/dist/src/transform/comments/prettier/language-js/comments.js

@@ -1,11 +1,3 @@
-/**
- * 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
- */
 'use strict';
 
 const {
@@ -36,57 +28,20 @@ const {
   locStart,
   locEnd
 } = require('./loc.js');
-/**
- * @typedef {import("./types/estree").Node} Node
- * @typedef {import("./types/estree").Comment} Comment
- * @typedef {import("../common/ast-path")} AstPath
- *
- * @typedef {Object} CommentContext
- * @property {Comment} comment
- * @property {Node} precedingNode
- * @property {Node} enclosingNode
- * @property {Node} followingNode
- * @property {string} text
- * @property {any} options
- * @property {Node} ast
- * @property {boolean} isLastComment
- */
-
-/**
- * @param {CommentContext} context
- * @returns {boolean}
- */
-
 
 function handleOwnLineComment(context) {
   return [handleIgnoreComments, handleLastFunctionArgComments, handleMemberExpressionComments, handleIfStatementComments, handleWhileComments, handleTryStatementComments, handleClassComments, handleImportSpecifierComments, handleForComments, handleUnionTypeComments, handleMatchOrPatternComments, handleOnlyComments, handleImportDeclarationComments, handleAssignmentPatternComments, handleMethodNameComments, handleLabeledStatementComments].some(fn => fn(context));
 }
-/**
- * @param {CommentContext} context
- * @returns {boolean}
- */
-
 
 function handleEndOfLineComment(context) {
   return [handleClosureTypeCastComments, handleLastFunctionArgComments, handleConditionalExpressionComments, handleImportSpecifierComments, handleIfStatementComments, handleWhileComments, handleTryStatementComments, handleClassComments, handleLabeledStatementComments, handleCallExpressionComments, handlePropertyComments, handleOnlyComments, handleTypeAliasComments, handleVariableDeclaratorComments].some(fn => fn(context));
 }
-/**
- * @param {CommentContext} context
- * @returns {boolean}
- */
-
 
 function handleRemainingComment(context) {
   return [handleIgnoreComments, handleIfStatementComments, handleWhileComments, handleObjectPropertyAssignment, handleCommentInEmptyParens, handleMethodNameComments, handleOnlyComments, handleCommentAfterArrowParams, handleFunctionNameComments, handleTSMappedTypeComments, handleBreakAndContinueStatementComments, handleTSFunctionTrailingComments].some(fn => fn(context));
 }
-/**
- * @param {Node} node
- * @returns {void}
- */
-
 
 function addBlockStatementFirstComment(node, comment) {
-  // @ts-expect-error
   const firstNonEmptyNode = (node.body || node.properties).find(({
     type
   }) => type !== 'EmptyStatement');
@@ -97,11 +52,6 @@ function addBlockStatementFirstComment(node, comment) {
     addDanglingComment(node, comment);
   }
 }
-/**
- * @param {Node} node
- * @returns {void}
- */
-
 
 function addBlockOrNotComment(node, comment) {
   if (node.type === 'BlockStatement') {
@@ -121,23 +71,7 @@ function handleClosureTypeCastComments({
   }
 
   return false;
-} // There are often comments before the else clause of if statements like
-//
-//   if (1) { ... }
-//   // comment
-//   else { ... }
-//
-// They are being attached as leading comments of the BlockExpression which
-// is not well printed. What we want is to instead move the comment inside
-// of the block and make it leadingComment of the first element of the block
-// or dangling comment of the block if there is nothing inside
-//
-//   if (1) { ... }
-//   else {
-//     // comment
-//     ...
-//   }
-
+}
 
 function handleIfStatementComments({
   comment,
@@ -148,22 +82,14 @@ function handleIfStatementComments({
 }) {
   if (!enclosingNode || enclosingNode.type !== 'IfStatement' || !followingNode) {
     return false;
-  } // We unfortunately have no way using the AST or location of nodes to know
-  // if the comment is positioned before the condition parenthesis:
-  //   if (a /* comment */) {}
-  // The only workaround I found is to look at the next character to see if
-  // it is a ).
-
+  }
 
   const nextCharacter = getNextNonSpaceNonCommentCharacter(text, comment, locEnd);
 
   if (nextCharacter === ')') {
     addTrailingComment(precedingNode, comment);
     return true;
-  } // Comments before `else`:
-  // - treat as trailing comments of the consequent, if it's a BlockStatement
-  // - treat as a dangling comment otherwise
-
+  }
 
   if (precedingNode === enclosingNode.consequent && followingNode === enclosingNode.alternate) {
     if (precedingNode.type === 'BlockStatement') {
@@ -183,12 +109,7 @@ function handleIfStatementComments({
   if (followingNode.type === 'IfStatement') {
     addBlockOrNotComment(followingNode.consequent, comment);
     return true;
-  } // For comments positioned after the condition parenthesis in an if statement
-  // before the consequent without brackets on, such as
-  // if (a) /* comment */ true,
-  // we look at the next character to see if the following node
-  // is the consequent for the if statement
-
+  }
 
   if (enclosingNode.consequent === followingNode) {
     addLeadingComment(followingNode, comment);
@@ -207,12 +128,7 @@ function handleWhileComments({
 }) {
   if (!enclosingNode || enclosingNode.type !== 'WhileStatement' || !followingNode) {
     return false;
-  } // We unfortunately have no way using the AST or location of nodes to know
-  // if the comment is positioned before the condition parenthesis:
-  //   while (a /* comment */) {}
-  // The only workaround I found is to look at the next character to see if
-  // it is a ).
-
+  }
 
   const nextCharacter = getNextNonSpaceNonCommentCharacter(text, comment, locEnd);
 
@@ -232,8 +148,7 @@ function handleWhileComments({
   }
 
   return false;
-} // Same as IfStatement but for TryStatement
-
+}
 
 function handleTryStatementComments({
   comment,
@@ -326,9 +241,7 @@ function handleClassComments({
     if (enclosingNode.body && followingNode === enclosingNode.body) {
       addBlockStatementFirstComment(enclosingNode.body, comment);
       return true;
-    } // Don't add leading comments to `implements`, `extends`, `mixins` to
-    // avoid printing the comment after the keyword.
-
+    }
 
     if (followingNode) {
       for (const prop of ['implements', 'extends', 'mixins']) {
@@ -354,18 +267,10 @@ function handleMethodNameComments({
   enclosingNode,
   text
 }) {
-  // This is only needed for estree parsers (flow, typescript) to attach
-  // after a method name:
-  // obj = { fn /*comment*/() {} };
-  if (enclosingNode && precedingNode && ( // "MethodDefinition" is handled in getCommentChildNodes
-  enclosingNode.type === 'Property' || enclosingNode.type === 'TSDeclareMethod' || enclosingNode.type === 'TSAbstractMethodDefinition') && precedingNode.type === 'Identifier' && enclosingNode.key === precedingNode && // special Property case: { key: /*comment*/(value) };
-  // comment should be attached to value instead of key
-  getNextNonSpaceNonCommentCharacter(text, precedingNode, locEnd) !== ':') {
+  if (enclosingNode && precedingNode && (enclosingNode.type === 'Property' || enclosingNode.type === 'TSDeclareMethod' || enclosingNode.type === 'TSAbstractMethodDefinition') && precedingNode.type === 'Identifier' && enclosingNode.key === precedingNode && getNextNonSpaceNonCommentCharacter(text, precedingNode, locEnd) !== ':') {
     addTrailingComment(precedingNode, comment);
     return true;
-  } // Print comments between decorators and class methods as a trailing comment
-  // on the decorator node instead of the method node
-
+  }
 
   if (precedingNode && enclosingNode && precedingNode.type === 'Decorator' && (enclosingNode.type === 'ClassMethod' || enclosingNode.type === 'ClassProperty' || enclosingNode.type === 'PropertyDefinition' || enclosingNode.type === 'TSAbstractPropertyDefinition' || enclosingNode.type === 'TSAbstractMethodDefinition' || enclosingNode.type === 'TSDeclareMethod' || enclosingNode.type === 'MethodDefinition')) {
     addTrailingComment(precedingNode, comment);
@@ -419,9 +324,7 @@ function handleCommentInEmptyParens({
 }) {
   if (getNextNonSpaceNonCommentCharacter(text, comment, locEnd) !== ')') {
     return false;
-  } // Only add dangling comments to fix the case when no params are present,
-  // i.e. a function without any argument.
-
+  }
 
   if (enclosingNode && (isRealFunctionLikeNode(enclosingNode) && getFunctionParameters(enclosingNode).length === 0 || isCallLikeExpression(enclosingNode) && getCallArguments(enclosingNode).length === 0)) {
     addDanglingComment(enclosingNode, comment);
@@ -443,12 +346,10 @@ function handleLastFunctionArgComments({
   followingNode,
   text
 }) {
-  // Flow function type definitions
   if (precedingNode && precedingNode.type === 'FunctionTypeParam' && enclosingNode && enclosingNode.type === 'FunctionTypeAnnotation' && followingNode && followingNode.type !== 'FunctionTypeParam') {
     addTrailingComment(precedingNode, comment);
     return true;
-  } // Real functions and TypeScript function type definitions
-
+  }
 
   if (precedingNode && (precedingNode.type === 'Identifier' || precedingNode.type === 'AssignmentPattern') && enclosingNode && isRealFunctionLikeNode(enclosingNode) && getNextNonSpaceNonCommentCharacter(text, comment, locEnd) === ')') {
     addTrailingComment(precedingNode, comment);
@@ -600,7 +501,6 @@ function handleOnlyComments({
   ast,
   isLastComment
 }) {
-  // With Flow the enclosingNode is undefined so use the AST instead.
   if (ast && ast.body && ast.body.length === 0) {
     if (isLastComment) {
       addDanglingComment(ast, comment);
@@ -740,44 +640,19 @@ function handleTSMappedTypeComments({
 
   return false;
 }
-/**
- * @param {Node} node
- * @returns {boolean}
- */
-
 
 function isRealFunctionLikeNode(node) {
   return node.type === 'ArrowFunctionExpression' || node.type === 'FunctionExpression' || node.type === 'FunctionDeclaration' || node.type === 'ObjectMethod' || node.type === 'ClassMethod' || node.type === 'TSDeclareFunction' || node.type === 'TSCallSignatureDeclaration' || node.type === 'TSConstructSignatureDeclaration' || node.type === 'TSMethodSignature' || node.type === 'TSConstructorType' || node.type === 'TSFunctionType' || node.type === 'TSDeclareMethod';
 }
-/**
- * @param {any} node
- * @returns {Node[] | void}
- */
-
 
 function getCommentChildNodes(node, options) {
-  // Prevent attaching comments to FunctionExpression in this case:
-  //     class Foo {
-  //       bar() // comment
-  //       {
-  //         baz();
-  //       }
-  //     }
   if ((options.parser === 'typescript' || options.parser === 'flow' || options.parser === 'espree' || options.parser === 'meriyah' || options.parser === '__babel_estree') && node.type === 'MethodDefinition' && node.value && node.value.type === 'FunctionExpression' && getFunctionParameters(node.value).length === 0 && !node.value.returnType && !isNonEmptyArray(node.value.typeParameters) && node.value.body) {
     return [...(node.decorators || []), node.key, node.value.body];
   }
 }
-/**
- * @param {Comment} comment
- * @returns {boolean}
- */
-
 
 function isTypeCastComment(comment) {
-  return isBlockComment(comment) && comment.value[0] === '*' && // TypeScript expects the type to be enclosed in curly brackets, however
-  // Closure Compiler accepts types in parens and even without any delimiters at all.
-  // That's why we just search for "@type".
-  /@type\b/.test(comment.value);
+  return isBlockComment(comment) && comment.value[0] === '*' && /@type\b/.test(comment.value);
 }
 
 module.exports = {

package/dist/src/transform/comments/prettier/language-js/loc.js

@@ -1,25 +1,13 @@
-/**
- * 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
- */
 'use strict';
 
 const {
   isNonEmptyArray
 } = require('../common/util.js');
-/**
- * @typedef {import("./types/estree").Node} Node
- */
-
 
 function locStart(node, opts) {
   const {
     ignoreDecorators
-  } = opts || {}; // Handle nodes with decorators. They should start at the first decorator
+  } = opts || {};
 
   if (!ignoreDecorators) {
     const decorators = node.declaration && node.declaration.decorators || node.decorators;

package/dist/src/transform/comments/prettier/language-js/printer-estree.js

@@ -1,11 +1,3 @@
-/**
- * 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
- */
 'use strict';
 
 const handleComments = require('./comments.js');
@@ -16,8 +8,7 @@ const {
 } = require('./utils.js');
 
 function canAttachComment(node) {
-  return node.type && !isBlockComment(node) && !isLineComment(node) && node.type !== 'EmptyStatement' && node.type !== 'TemplateElement' && node.type !== 'Import' && // `babel-ts` don't have similar node for `class Foo { bar() /* bat */; }`
-  node.type !== 'TSEmptyBodyFunctionExpression';
+  return node.type && !isBlockComment(node) && !isLineComment(node) && node.type !== 'EmptyStatement' && node.type !== 'TemplateElement' && node.type !== 'Import' && node.type !== 'TSEmptyBodyFunctionExpression';
 }
 
 module.exports = {

package/dist/src/transform/comments/prettier/language-js/utils.js

@@ -1,45 +1,16 @@
-/**
- * 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
- */
 'use strict';
-/**
- * @param {Comment} comment
- * @returns {boolean}
- */
 
 function isBlockComment(comment) {
-  return comment.type === 'Block' || comment.type === 'CommentBlock' || // `meriyah`
-  comment.type === 'MultiLine';
+  return comment.type === 'Block' || comment.type === 'CommentBlock' || comment.type === 'MultiLine';
 }
-/**
- * @param {Comment} comment
- * @returns {boolean}
- */
-
 
 function isLineComment(comment) {
-  return comment.type === 'Line' || comment.type === 'CommentLine' || // `meriyah` has `SingleLine`, `HashbangComment`, `HTMLOpen`, and `HTMLClose`
-  comment.type === 'SingleLine' || comment.type === 'HashbangComment' || comment.type === 'HTMLOpen' || comment.type === 'HTMLClose';
+  return comment.type === 'Line' || comment.type === 'CommentLine' || comment.type === 'SingleLine' || comment.type === 'HashbangComment' || comment.type === 'HTMLOpen' || comment.type === 'HTMLClose';
 }
-/**
- * @param {Node} node
- * @returns {boolean}
- */
-
 
 function isCallExpression(node) {
   return node && (node.type === 'CallExpression' || node.type === 'OptionalCallExpression');
 }
-/**
- * @param {Node} node
- * @returns {boolean}
- */
-
 
 function isMemberExpression(node) {
   return node && (node.type === 'MemberExpression' || node.type === 'OptionalMemberExpression');
@@ -56,8 +27,7 @@ function getFunctionParameters(node) {
 
   if (node.this) {
     parameters.push(node.this);
-  } // `params` vs `parameters` - see https://github.com/babel/babel/issues/9231
-
+  }
 
   if (Array.isArray(node.parameters)) {
     parameters.push(...node.parameters);