hermes-transform 0.28.0 → 0.29.0

package/dist/detachedNode.js

@@ -147,6 +147,7 @@ function shallowCloneNode(node, newProps, config = {}) {
 
 
 function deepCloneNode(node, newProps) {
+  // $FlowFixMe[unsafe-object-assign]
   const clone = Object.assign(JSON.parse(JSON.stringify(node, (key, value) => {
     // null out parent pointers
     if (key === 'parent') {

package/dist/detachedNode.js.flow

@@ -164,6 +164,7 @@ export function deepCloneNode<T: ESNode>(
   node: T,
   newProps: {...},
 ): DetachedNode<T> {
+  // $FlowFixMe[unsafe-object-assign]
   const clone: DetachedNode<T> = Object.assign(
     JSON.parse(
       JSON.stringify(node, (key, value) => {

package/dist/generated/node-types.js

@@ -37,7 +37,6 @@ var _exportNames = {
   BigIntLiteralTypeAnnotation: true,
   BigIntTypeAnnotation: true,
   BinaryExpression: true,
-  BlockStatement: true,
   BooleanLiteralTypeAnnotation: true,
   BooleanTypeAnnotation: true,
   BreakStatement: true,
@@ -219,7 +218,6 @@ exports.AwaitExpression = AwaitExpression;
 exports.BigIntLiteralTypeAnnotation = BigIntLiteralTypeAnnotation;
 exports.BigIntTypeAnnotation = BigIntTypeAnnotation;
 exports.BinaryExpression = BinaryExpression;
-exports.BlockStatement = BlockStatement;
 exports.BooleanLiteralTypeAnnotation = BooleanLiteralTypeAnnotation;
 exports.BooleanTypeAnnotation = BooleanTypeAnnotation;
 exports.BreakStatement = BreakStatement;
@@ -512,15 +510,6 @@ function BinaryExpression(props) {
   return node;
 }
 
-function BlockStatement(props) {
-  const node = (0, _detachedNode.detachedProps)(props.parent, {
-    type: 'BlockStatement',
-    body: props.body.map(n => (0, _detachedNode.asDetachedNodeForCodeGen)(n))
-  });
-  (0, _detachedNode.setParentPointersInDirectChildren)(node);
-  return node;
-}
-
 function BooleanLiteralTypeAnnotation(props) {
   const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'BooleanLiteralTypeAnnotation',
@@ -1184,7 +1173,7 @@ function ImportExpression(props) {
   const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'ImportExpression',
     source: (0, _detachedNode.asDetachedNodeForCodeGen)(props.source),
-    attributes: (0, _detachedNode.asDetachedNodeForCodeGen)(props.attributes)
+    options: (0, _detachedNode.asDetachedNodeForCodeGen)(props.options)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;

package/dist/generated/node-types.js.flow

@@ -35,7 +35,6 @@ import type {
   BigIntLiteralTypeAnnotation as BigIntLiteralTypeAnnotationType,
   BigIntTypeAnnotation as BigIntTypeAnnotationType,
   BinaryExpression as BinaryExpressionType,
-  BlockStatement as BlockStatementType,
   BooleanLiteralTypeAnnotation as BooleanLiteralTypeAnnotationType,
   BooleanTypeAnnotation as BooleanTypeAnnotationType,
   BreakStatement as BreakStatementType,
@@ -269,10 +268,6 @@ export type BinaryExpressionProps = {
   +operator: BinaryExpressionType['operator'],
 };
 
-export type BlockStatementProps = {
-  +body: $ReadOnlyArray<MaybeDetachedNode<BlockStatementType['body'][number]>>,
-};
-
 export type BooleanLiteralTypeAnnotationProps = {
   +value: BooleanLiteralTypeAnnotationType['value'],
   +raw: BooleanLiteralTypeAnnotationType['raw'],
@@ -686,7 +681,7 @@ export type ImportDefaultSpecifierProps = {
 
 export type ImportExpressionProps = {
   +source: MaybeDetachedNode<ImportExpressionType['source']>,
-  +attributes?: ?MaybeDetachedNode<ImportExpressionType['attributes']>,
+  +options?: ?MaybeDetachedNode<ImportExpressionType['options']>,
 };
 
 export type ImportNamespaceSpecifierProps = {
@@ -1431,18 +1426,6 @@ export function BinaryExpression(props: {
   return node;
 }
 
-export function BlockStatement(props: {
-  ...BlockStatementProps,
-  +parent?: ESNode,
-}): DetachedNode<BlockStatementType> {
-  const node = detachedProps<BlockStatementType>((props.parent: $FlowFixMe), {
-    type: 'BlockStatement',
-    body: props.body.map(n => asDetachedNodeForCodeGen(n)),
-  });
-  setParentPointersInDirectChildren((node: $FlowFixMe));
-  return node;
-}
-
 export function BooleanLiteralTypeAnnotation(props: {
   ...BooleanLiteralTypeAnnotationProps,
   +parent?: ESNode,
@@ -2368,7 +2351,7 @@ export function ImportExpression(props: {
   const node = detachedProps<ImportExpressionType>((props.parent: $FlowFixMe), {
     type: 'ImportExpression',
     source: asDetachedNodeForCodeGen(props.source),
-    attributes: asDetachedNodeForCodeGen(props.attributes),
+    options: asDetachedNodeForCodeGen(props.options),
   });
   setParentPointersInDirectChildren((node: $FlowFixMe));
   return node;

package/dist/generated/special-case-node-types/misc.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.ArrowFunctionExpression = ArrowFunctionExpression;
+exports.BlockStatement = BlockStatement;
 exports.ClassDeclaration = ClassDeclaration;
 exports.DeclareFunction = DeclareFunction;
 exports.Identifier = Identifier;
@@ -144,4 +145,14 @@ function MemberExpression(props) {
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
+} // Ignore the hermes-specific `implicit` property.
+
+
+function BlockStatement(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
+    type: 'BlockStatement',
+    body: props.body.map(n => (0, _detachedNode.asDetachedNode)(n))
+  });
+  (0, _detachedNode.setParentPointersInDirectChildren)(node);
+  return node;
 }

package/dist/generated/special-case-node-types/misc.js.flow

@@ -10,12 +10,14 @@
 
 import type {
   ArrowFunctionExpression as ArrowFunctionExpressionType,
+  BlockStatement as BlockStatementType,
   ClassDeclaration as ClassDeclarationType,
   DeclareFunction as DeclareFunctionType,
   ESNode,
   FunctionTypeAnnotation as FunctionTypeAnnotationType,
   Identifier as IdentifierType,
   InterpreterDirective as InterpreterDirectiveType,
+  Statement as StatementType,
   Token as TokenType,
   Comment as CommentType,
   TemplateElement as TemplateElementType,
@@ -237,3 +239,19 @@ export function MemberExpression(props: {
   setParentPointersInDirectChildren(node);
   return node;
 }
+
+// Ignore the hermes-specific `implicit` property.
+export type BlockStatementProps = {
+  +body: $ReadOnlyArray<MaybeDetachedNode<StatementType>>,
+};
+export function BlockStatement(props: {
+  ...$ReadOnly<BlockStatementProps>,
+  +parent?: ESNode,
+}): DetachedNode<BlockStatementType> {
+  const node = detachedProps<BlockStatementType>(props.parent, {
+    type: 'BlockStatement',
+    body: props.body.map(n => asDetachedNode(n)),
+  });
+  setParentPointersInDirectChildren(node);
+  return node;
+}

package/dist/src/detachedNode.js

@@ -0,0 +1,178 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.asDetachedNode = void 0;
+exports.asDetachedNodeForCodeGen = asDetachedNodeForCodeGen;
+exports.deepCloneNode = deepCloneNode;
+exports.detachedProps = detachedProps;
+exports.getOriginalNode = getOriginalNode;
+exports.isDetachedNode = isDetachedNode;
+exports.setParentPointersInDirectChildren = setParentPointersInDirectChildren;
+exports.shallowCloneNode = shallowCloneNode;
+exports.updateAllParentPointers = updateAllParentPointers;
+
+var _hermesParser = require("hermes-parser");
+
+/**
+ * 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
+ */
+const DETACHED_MARKER = Symbol.for('hermes-transform - Detached AST Node');
+const ORIGINAL_NODE = Symbol.for('hermes-transform - Original Node');
+
+function isDetachedNode(node) {
+  // $FlowExpectedError[invalid-in-lhs] flow doesn't support symbols as keys
+  return DETACHED_MARKER in node;
+}
+
+function getOriginalNode(node) {
+  // $FlowExpectedError[prop-missing]
+  return node[ORIGINAL_NODE];
+}
+/* $FlowExpectedError[unclear-type] Type safety is not needed for generated
+ * code, this avoids us always having to pass a generic property within codegen */
+
+
+function asDetachedNodeForCodeGen(node) {
+  if (node == null) {
+    return null;
+  }
+
+  if (isDetachedNode(node)) {
+    return node;
+  }
+
+  return shallowCloneNode(node, {});
+}
+
+const asDetachedNode = (node, {
+  useDeepClone
+} = {
+  useDeepClone: false
+}) => {
+  if (node == null) {
+    return null;
+  }
+
+  if (isDetachedNode(node)) {
+    return node;
+  }
+
+  return useDeepClone ? deepCloneNode(node, {}) : shallowCloneNode(node, {});
+}; // used by the node type function codegen
+
+
+exports.asDetachedNode = asDetachedNode;
+
+function detachedProps(parent, props, config = {}) {
+  // $FlowExpectedError[incompatible-type]
+  const detachedNode = { ...props,
+    ...((config == null ? void 0 : config.preserveLocation) !== true ? {
+      // if this is [0,0] AND the file has a docblock then prettier will insert newlines between
+      // certain detached nodes. Because of "intended" formatting behaviour (https://github.com/prettier/prettier/issues/12078)
+      // this can cause us to output weirdly formatted code that should have been collapsed.
+      //
+      // prettier works backwards from the position you give it to find newlines or non whitespace
+      // tokens and uses this to determine if newlines should be inserted between nodes.
+      // By placing the range at [1, 1] we can ensure a token is always found before a newline
+      // and therefore no newlines will be placed between nodes.
+      //
+      // NOTE: we will still run into the bug if there is weird code like a docblock with whitespace
+      //       characters before it. However we assume this isn't going to happen because any file
+      //       already formatted by prettier will have that whitespace removed.
+      // We considered a more complex solution involving traversing the AST and manually updating
+      // detached node ranges after mutations are applied - however this is a lot heavier and will
+      // probably never be needed.
+      range: [1, 1],
+      loc: {
+        start: {
+          line: 1,
+          column: 0
+        },
+        end: {
+          line: 1,
+          column: 0
+        }
+      }
+    } : {}),
+    // if not provided, then we purposely don't set this here
+    // and will rely on the tooling to update it as appropriate.
+    // nothing should be reading from this before it's set anyway.
+    parent: parent
+  }; // mark the node as detached
+
+  Object.defineProperty(detachedNode, DETACHED_MARKER, {
+    configurable: false,
+    enumerable: false,
+    value: true,
+    writable: false
+  });
+
+  if (config.originalNode) {
+    Object.defineProperty(detachedNode, ORIGINAL_NODE, {
+      configurable: false,
+      enumerable: false,
+      value: config.originalNode,
+      writable: false
+    });
+  }
+
+  return detachedNode;
+}
+/**
+ * Shallowly clones the node, but not its children.
+ */
+
+
+function shallowCloneNode(node, newProps, config = {}) {
+  var _config$preserveLocat, _config$originalNode;
+
+  return detachedProps(null, { ...node,
+    ...newProps
+  }, {
+    preserveLocation: (_config$preserveLocat = config.preserveLocation) != null ? _config$preserveLocat : true,
+    originalNode: (_config$originalNode = config.originalNode) != null ? _config$originalNode : node
+  });
+}
+/**
+ * Deeply clones node and its entire tree.
+ */
+
+
+function deepCloneNode(node, newProps) {
+  // $FlowFixMe[unsafe-object-assign]
+  const clone = Object.assign(JSON.parse(JSON.stringify(node, (key, value) => {
+    // null out parent pointers
+    if (key === 'parent') {
+      return undefined;
+    }
+
+    return value;
+  })), newProps);
+  updateAllParentPointers(clone); // $FlowExpectedError[class-object-subtyping]
+
+  return detachedProps(null, clone);
+}
+/**
+ * Corrects the parent pointers in direct children of the given node
+ */
+
+
+function setParentPointersInDirectChildren(node) {
+  _hermesParser.astNodeMutationHelpers.setParentPointersInDirectChildren(node);
+}
+/**
+ * Traverses the entire subtree to ensure the parent pointers are set correctly
+ */
+
+
+function updateAllParentPointers(node) {
+  _hermesParser.astNodeMutationHelpers.updateAllParentPointers(node);
+}