hermes-transform 0.5.0 → 0.8.0

package/dist/generated/node-types.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.
@@ -8,6 +8,10 @@
  * @format
  */
 
+// lint directives to let us do some basic validation of generated files
+/* eslint no-undef: 'error', no-unused-vars: ['error', {vars: "local"}], no-redeclare: 'error' */
+/* global $NonMaybeType, $Partial, $ReadOnly, $ReadOnlyArray */
+
 'use strict';
 
 import type {
@@ -19,6 +23,7 @@ import type {
   AssignmentExpression as AssignmentExpressionType,
   AssignmentPattern as AssignmentPatternType,
   AwaitExpression as AwaitExpressionType,
+  BigIntLiteralTypeAnnotation as BigIntLiteralTypeAnnotationType,
   BinaryExpression as BinaryExpressionType,
   BlockStatement as BlockStatementType,
   BooleanLiteralTypeAnnotation as BooleanLiteralTypeAnnotationType,
@@ -26,12 +31,11 @@ import type {
   BreakStatement as BreakStatementType,
   CallExpression as CallExpressionType,
   CatchClause as CatchClauseType,
+  ChainExpression as ChainExpressionType,
   ClassBody as ClassBodyType,
   ClassDeclaration as ClassDeclarationType,
   ClassExpression as ClassExpressionType,
   ClassImplements as ClassImplementsType,
-  ClassPrivateProperty as ClassPrivatePropertyType,
-  ClassProperty as ClassPropertyType,
   ConditionalExpression as ConditionalExpressionType,
   ContinueStatement as ContinueStatementType,
   DebuggerStatement as DebuggerStatementType,
@@ -62,7 +66,6 @@ import type {
   ExportAllDeclaration as ExportAllDeclarationType,
   ExportDefaultDeclaration as ExportDefaultDeclarationType,
   ExportNamedDeclaration as ExportNamedDeclarationType,
-  ExportNamespaceSpecifier as ExportNamespaceSpecifierType,
   ExportSpecifier as ExportSpecifierType,
   ExpressionStatement as ExpressionStatementType,
   ForInStatement as ForInStatementType,
@@ -121,11 +124,10 @@ import type {
   ObjectTypeProperty as ObjectTypePropertyType,
   ObjectTypeSpreadProperty as ObjectTypeSpreadPropertyType,
   OpaqueType as OpaqueTypeType,
-  OptionalCallExpression as OptionalCallExpressionType,
   OptionalIndexedAccessType as OptionalIndexedAccessTypeType,
-  OptionalMemberExpression as OptionalMemberExpressionType,
-  PrivateName as PrivateNameType,
+  PrivateIdentifier as PrivateIdentifierType,
   Property as PropertyType,
+  PropertyDefinition as PropertyDefinitionType,
   QualifiedTypeIdentifier as QualifiedTypeIdentifierType,
   RestElement as RestElementType,
   ReturnStatement as ReturnStatementType,
@@ -202,6 +204,10 @@ export type AwaitExpressionProps = {
   +argument: DetachedNode<AwaitExpressionType['argument']>,
 };
 
+export type BigIntLiteralTypeAnnotationProps = {
+  +raw: BigIntLiteralTypeAnnotationType['raw'],
+};
+
 export type BinaryExpressionProps = {
   +left: DetachedNode<BinaryExpressionType['left']>,
   +right: DetachedNode<BinaryExpressionType['right']>,
@@ -236,6 +242,10 @@ export type CatchClauseProps = {
   +body: DetachedNode<CatchClauseType['body']>,
 };
 
+export type ChainExpressionProps = {
+  +expression: DetachedNode<ChainExpressionType['expression']>,
+};
+
 export type ClassBodyProps = {
   +body: $ReadOnlyArray<DetachedNode<ClassBodyType['body'][number]>>,
 };
@@ -277,27 +287,6 @@ export type ClassImplementsProps = {
   +typeParameters?: ?DetachedNode<ClassImplementsType['typeParameters']>,
 };
 
-export type ClassPrivatePropertyProps = {
-  +key: DetachedNode<ClassPrivatePropertyType['key']>,
-  +value?: ?DetachedNode<ClassPrivatePropertyType['value']>,
-  +static: ClassPrivatePropertyType['static'],
-  +declare: ClassPrivatePropertyType['declare'],
-  +optional: ClassPrivatePropertyType['optional'],
-  +variance?: ?DetachedNode<ClassPrivatePropertyType['variance']>,
-  +typeAnnotation?: ?DetachedNode<ClassPrivatePropertyType['typeAnnotation']>,
-};
-
-export type ClassPropertyProps = {
-  +key: DetachedNode<ClassPropertyType['key']>,
-  +value?: ?DetachedNode<ClassPropertyType['value']>,
-  +computed: ClassPropertyType['computed'],
-  +static: ClassPropertyType['static'],
-  +declare: ClassPropertyType['declare'],
-  +optional: ClassPropertyType['optional'],
-  +variance?: ?DetachedNode<ClassPropertyType['variance']>,
-  +typeAnnotation?: ?DetachedNode<ClassPropertyType['typeAnnotation']>,
-};
-
 export type ConditionalExpressionProps = {
   +test: DetachedNode<ConditionalExpressionType['test']>,
   +alternate: DetachedNode<ConditionalExpressionType['alternate']>,
@@ -440,6 +429,7 @@ export type EnumSymbolBodyProps = {
 export type ExistsTypeAnnotationProps = {};
 
 export type ExportAllDeclarationProps = {
+  +exported?: ?DetachedNode<ExportAllDeclarationType['exported']>,
   +source: DetachedNode<ExportAllDeclarationType['source']>,
   +exportKind: ExportAllDeclarationType['exportKind'],
 };
@@ -457,10 +447,6 @@ export type ExportNamedDeclarationProps = {
   +exportKind: ExportNamedDeclarationType['exportKind'],
 };
 
-export type ExportNamespaceSpecifierProps = {
-  +exported: DetachedNode<ExportNamespaceSpecifierType['exported']>,
-};
-
 export type ExportSpecifierProps = {
   +exported: DetachedNode<ExportSpecifierType['exported']>,
   +local: DetachedNode<ExportSpecifierType['local']>,
@@ -805,30 +791,14 @@ export type OpaqueTypeProps = {
   +supertype?: ?DetachedNode<OpaqueTypeType['supertype']>,
 };
 
-export type OptionalCallExpressionProps = {
-  +callee: DetachedNode<OptionalCallExpressionType['callee']>,
-  +typeArguments?: ?DetachedNode<OptionalCallExpressionType['typeArguments']>,
-  +arguments: $ReadOnlyArray<
-    DetachedNode<OptionalCallExpressionType['arguments'][number]>,
-  >,
-  +optional: OptionalCallExpressionType['optional'],
-};
-
 export type OptionalIndexedAccessTypeProps = {
   +objectType: DetachedNode<OptionalIndexedAccessTypeType['objectType']>,
   +indexType: DetachedNode<OptionalIndexedAccessTypeType['indexType']>,
   +optional: OptionalIndexedAccessTypeType['optional'],
 };
 
-export type OptionalMemberExpressionProps = {
-  +object: DetachedNode<OptionalMemberExpressionType['object']>,
-  +property: DetachedNode<OptionalMemberExpressionType['property']>,
-  +computed: OptionalMemberExpressionType['computed'],
-  +optional: OptionalMemberExpressionType['optional'],
-};
-
-export type PrivateNameProps = {
-  +id: DetachedNode<PrivateNameType['id']>,
+export type PrivateIdentifierProps = {
+  +name: PrivateIdentifierType['name'],
 };
 
 export type PropertyProps = {
@@ -840,6 +810,17 @@ export type PropertyProps = {
   +shorthand: PropertyType['shorthand'],
 };
 
+export type PropertyDefinitionProps = {
+  +key: DetachedNode<PropertyDefinitionType['key']>,
+  +value?: ?DetachedNode<PropertyDefinitionType['value']>,
+  +computed: PropertyDefinitionType['computed'],
+  +static: PropertyDefinitionType['static'],
+  +declare: PropertyDefinitionType['declare'],
+  +optional: PropertyDefinitionType['optional'],
+  +variance?: ?DetachedNode<PropertyDefinitionType['variance']>,
+  +typeAnnotation?: ?DetachedNode<PropertyDefinitionType['typeAnnotation']>,
+};
+
 export type QualifiedTypeIdentifierProps = {
   +qualification: DetachedNode<QualifiedTypeIdentifierType['qualification']>,
   +id: DetachedNode<QualifiedTypeIdentifierType['id']>,
@@ -865,6 +846,7 @@ export type SpreadElementProps = {
 
 export type StringLiteralTypeAnnotationProps = {
   +value: StringLiteralTypeAnnotationType['value'],
+  +raw: StringLiteralTypeAnnotationType['raw'],
 };
 
 export type StringTypeAnnotationProps = {};
@@ -1106,6 +1088,21 @@ export function AwaitExpression({
   return node;
 }
 
+export function BigIntLiteralTypeAnnotation({
+  parent,
+  ...props
+}: {
+  ...$ReadOnly<BigIntLiteralTypeAnnotationProps>,
+  +parent?: ESNode,
+}): DetachedNode<BigIntLiteralTypeAnnotationType> {
+  const node = detachedProps<BigIntLiteralTypeAnnotationType>(parent, {
+    type: 'BigIntLiteralTypeAnnotation',
+    ...props,
+  });
+  setParentPointersInDirectChildren(node);
+  return node;
+}
+
 export function BinaryExpression({
   parent,
   ...props
@@ -1206,6 +1203,21 @@ export function CatchClause({
   return node;
 }
 
+export function ChainExpression({
+  parent,
+  ...props
+}: {
+  ...$ReadOnly<ChainExpressionProps>,
+  +parent?: ESNode,
+}): DetachedNode<ChainExpressionType> {
+  const node = detachedProps<ChainExpressionType>(parent, {
+    type: 'ChainExpression',
+    ...props,
+  });
+  setParentPointersInDirectChildren(node);
+  return node;
+}
+
 export function ClassBody({
   parent,
   ...props
@@ -1266,36 +1278,6 @@ export function ClassImplements({
   return node;
 }
 
-export function ClassPrivateProperty({
-  parent,
-  ...props
-}: {
-  ...$ReadOnly<ClassPrivatePropertyProps>,
-  +parent?: ESNode,
-}): DetachedNode<ClassPrivatePropertyType> {
-  const node = detachedProps<ClassPrivatePropertyType>(parent, {
-    type: 'ClassPrivateProperty',
-    ...props,
-  });
-  setParentPointersInDirectChildren(node);
-  return node;
-}
-
-export function ClassProperty({
-  parent,
-  ...props
-}: {
-  ...$ReadOnly<ClassPropertyProps>,
-  +parent?: ESNode,
-}): DetachedNode<ClassPropertyType> {
-  const node = detachedProps<ClassPropertyType>(parent, {
-    type: 'ClassProperty',
-    ...props,
-  });
-  setParentPointersInDirectChildren(node);
-  return node;
-}
-
 export function ConditionalExpression({
   parent,
   ...props
@@ -1726,21 +1708,6 @@ export function ExportNamedDeclaration({
   return node;
 }
 
-export function ExportNamespaceSpecifier({
-  parent,
-  ...props
-}: {
-  ...$ReadOnly<ExportNamespaceSpecifierProps>,
-  +parent?: ESNode,
-}): DetachedNode<ExportNamespaceSpecifierType> {
-  const node = detachedProps<ExportNamespaceSpecifierType>(parent, {
-    type: 'ExportNamespaceSpecifier',
-    ...props,
-  });
-  setParentPointersInDirectChildren(node);
-  return node;
-}
-
 export function ExportSpecifier({
   parent,
   ...props
@@ -2576,21 +2543,6 @@ export function OpaqueType({
   return node;
 }
 
-export function OptionalCallExpression({
-  parent,
-  ...props
-}: {
-  ...$ReadOnly<OptionalCallExpressionProps>,
-  +parent?: ESNode,
-}): DetachedNode<OptionalCallExpressionType> {
-  const node = detachedProps<OptionalCallExpressionType>(parent, {
-    type: 'OptionalCallExpression',
-    ...props,
-  });
-  setParentPointersInDirectChildren(node);
-  return node;
-}
-
 export function OptionalIndexedAccessType({
   parent,
   ...props
@@ -2606,45 +2558,45 @@ export function OptionalIndexedAccessType({
   return node;
 }
 
-export function OptionalMemberExpression({
+export function PrivateIdentifier({
   parent,
   ...props
 }: {
-  ...$ReadOnly<OptionalMemberExpressionProps>,
+  ...$ReadOnly<PrivateIdentifierProps>,
   +parent?: ESNode,
-}): DetachedNode<OptionalMemberExpressionType> {
-  const node = detachedProps<OptionalMemberExpressionType>(parent, {
-    type: 'OptionalMemberExpression',
+}): DetachedNode<PrivateIdentifierType> {
+  const node = detachedProps<PrivateIdentifierType>(parent, {
+    type: 'PrivateIdentifier',
     ...props,
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function PrivateName({
+export function Property({
   parent,
   ...props
 }: {
-  ...$ReadOnly<PrivateNameProps>,
+  ...$ReadOnly<PropertyProps>,
   +parent?: ESNode,
-}): DetachedNode<PrivateNameType> {
-  const node = detachedProps<PrivateNameType>(parent, {
-    type: 'PrivateName',
+}): DetachedNode<PropertyType> {
+  const node = detachedProps<PropertyType>(parent, {
+    type: 'Property',
     ...props,
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function Property({
+export function PropertyDefinition({
   parent,
   ...props
 }: {
-  ...$ReadOnly<PropertyProps>,
+  ...$ReadOnly<PropertyDefinitionProps>,
   +parent?: ESNode,
-}): DetachedNode<PropertyType> {
-  const node = detachedProps<PropertyType>(parent, {
-    type: 'Property',
+}): DetachedNode<PropertyDefinitionType> {
+  const node = detachedProps<PropertyDefinitionType>(parent, {
+    type: 'PropertyDefinition',
     ...props,
   });
   setParentPointersInDirectChildren(node);

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

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.ArrowFunctionExpression = ArrowFunctionExpression;
+exports.BigIntLiteral = BigIntLiteral;
 exports.BlockComment = BlockComment;
 exports.BooleanLiteral = BooleanLiteral;
 exports.Identifier = Identifier;
@@ -16,81 +17,82 @@ exports.TemplateElement = TemplateElement;
 
 var _detachedNode = require("../detachedNode");
 
-var _excluded = ["parent"],
-    _excluded2 = ["tail", "parent"],
-    _excluded3 = ["parent", "optional", "typeAnnotation"],
-    _excluded4 = ["parent"];
-
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
-function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
-
-function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
-
-function ArrowFunctionExpression(_ref) {
-  var parent = _ref.parent,
-      props = _objectWithoutProperties(_ref, _excluded);
-
-  var node = (0, _detachedNode.detachedProps)(parent, _objectSpread({
+/**
+ * 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
+ */
+
+/*
+These are a number of special-case node creation functions that we can't auto-generate.
+The list of exported functions here must be kept in sync with the `NODES_WITH_SPECIAL_HANDLING`
+list in `scripts/genTransformNodeTypes` to ensure there's no duplicates
+*/
+function ArrowFunctionExpression({
+  parent,
+  ...props
+}) {
+  const node = (0, _detachedNode.detachedProps)(parent, {
     type: 'ArrowFunctionExpression',
     id: null,
     // $FlowExpectedError[incompatible-use]
-    expression: props.body.type !== 'BlockStatement'
-  }, props));
+    expression: props.body.type !== 'BlockStatement',
+    ...props
+  });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 } // pattern/flags are on a subobject in the estree spec, but are flat on the hermes types
 // also the value is supposed to be a RegExp instance
 
 
-function RegExpLiteral(_ref2) {
-  var pattern = _ref2.pattern,
-      flags = _ref2.flags,
-      parent = _ref2.parent;
-  var value = new RegExp(pattern, flags);
+function RegExpLiteral({
+  pattern,
+  flags,
+  parent
+}) {
+  const value = new RegExp(pattern, flags);
   return (0, _detachedNode.detachedProps)(parent, {
     type: 'Literal',
-    value: value,
+    value,
     raw: value.toString(),
     regex: {
-      pattern: pattern,
-      flags: flags
+      pattern,
+      flags
     }
   });
 } // raw/cooked are on a subobject in the estree spec, but are flat on the hermes types
 
 
-function TemplateElement(_ref3) {
-  var tail = _ref3.tail,
-      parent = _ref3.parent,
-      value = _objectWithoutProperties(_ref3, _excluded2);
-
+function TemplateElement({
+  tail,
+  parent,
+  ...value
+}) {
   return (0, _detachedNode.detachedProps)(parent, {
     type: 'TemplateElement',
-    tail: tail,
-    value: value
+    tail,
+    value
   });
 } // Identifier has a bunch of stuff that usually you don't want to provide - so we have
 // this manual def to allow us to default some values
 
 
-function Identifier(_ref4) {
-  var parent = _ref4.parent,
-      _ref4$optional = _ref4.optional,
-      optional = _ref4$optional === void 0 ? false : _ref4$optional,
-      _ref4$typeAnnotation = _ref4.typeAnnotation,
-      typeAnnotation = _ref4$typeAnnotation === void 0 ? null : _ref4$typeAnnotation,
-      props = _objectWithoutProperties(_ref4, _excluded3);
-
-  var node = (0, _detachedNode.detachedProps)(parent, _objectSpread({
+function Identifier({
+  parent,
+  optional = false,
+  typeAnnotation = null,
+  ...props
+}) {
+  const node = (0, _detachedNode.detachedProps)(parent, {
     type: 'Identifier',
-    optional: optional,
-    typeAnnotation: typeAnnotation
-  }, props));
+    optional,
+    typeAnnotation,
+    ...props
+  });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 } //
@@ -98,33 +100,49 @@ function Identifier(_ref4) {
 //
 
 
-function BooleanLiteral(_ref5) {
-  var parent = _ref5.parent,
-      value = _ref5.value;
+function BigIntLiteral({
+  parent,
+  ...props
+}) {
+  var _props$raw;
+
+  const node = (0, _detachedNode.detachedProps)(parent, {
+    type: 'Literal',
+    ...props,
+    raw: (_props$raw = props.raw) != null ? _props$raw : `${props.value}n`,
+    bigint: `${props.value}`
+  });
+  (0, _detachedNode.setParentPointersInDirectChildren)(node);
+  return node;
+}
+
+function BooleanLiteral({
+  parent,
+  value
+}) {
   return (0, _detachedNode.detachedProps)(parent, {
     type: 'Literal',
     raw: value ? 'true' : 'false',
-    value: value
+    value
   });
 }
 
-function NumericLiteral(_ref6) {
-  var _props$raw;
-
-  var parent = _ref6.parent,
-      props = _objectWithoutProperties(_ref6, _excluded4);
+function NumericLiteral({
+  parent,
+  ...props
+}) {
+  var _props$raw2;
 
-  return (0, _detachedNode.detachedProps)(parent, _objectSpread(_objectSpread({
-    type: 'Literal'
-  }, props), {}, {
-    raw: (_props$raw = props.raw) !== null && _props$raw !== void 0 ? _props$raw : "".concat(props.value)
-  }));
+  return (0, _detachedNode.detachedProps)(parent, {
+    type: 'Literal',
+    ...props,
+    raw: (_props$raw2 = props.raw) != null ? _props$raw2 : `${props.value}`
+  });
 }
 
-function NullLiteral() {
-  var _ref7 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
-      parent = _ref7.parent;
-
+function NullLiteral({
+  parent
+} = {}) {
   return (0, _detachedNode.detachedProps)(parent, {
     type: 'Literal',
     value: null,
@@ -132,47 +150,50 @@ function NullLiteral() {
   });
 }
 
-function StringLiteral(_ref8) {
-  var parent = _ref8.parent,
-      rawIn = _ref8.raw,
-      value = _ref8.value;
-  var hasSingleQuote = value.includes('"');
-  var hasDoubleQuote = value.includes("'");
-  var raw = rawIn;
+function StringLiteral({
+  parent,
+  raw: rawIn,
+  value
+}) {
+  const hasSingleQuote = value.includes('"');
+  const hasDoubleQuote = value.includes("'");
+  let raw = rawIn;
 
   if (raw == null) {
     if (hasSingleQuote && hasDoubleQuote) {
-      raw = "'".concat(value.replace(/'/g, "\\'"), "'");
+      raw = `'${value.replace(/'/g, "\\'")}'`;
     } else if (hasSingleQuote) {
-      raw = "\"".concat(value, "\"");
+      raw = `"${value}"`;
     } else {
-      raw = "'".concat(value, "'");
+      raw = `'${value}'`;
     }
   }
 
   return (0, _detachedNode.detachedProps)(parent, {
     type: 'Literal',
-    raw: raw,
-    value: value
+    raw,
+    value
   });
 }
 
-function LineComment(_ref9) {
-  var value = _ref9.value;
+function LineComment({
+  value
+}) {
   // $FlowExpectedError[prop-missing]
   // $FlowExpectedError[incompatible-return]
   return (0, _detachedNode.detachedProps)(undefined, {
     type: 'Line',
-    value: value
+    value
   });
 }
 
-function BlockComment(_ref10) {
-  var value = _ref10.value;
+function BlockComment({
+  value
+}) {
   // $FlowExpectedError[prop-missing]
   // $FlowExpectedError[incompatible-return]
   return (0, _detachedNode.detachedProps)(undefined, {
     type: 'Block',
-    value: value
+    value
   });
 }