hermes-transform 0.9.0 → 0.10.1

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

@@ -0,0 +1,205 @@
+/**
+ * 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.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+import type {
+  ArrowFunctionExpression as ArrowFunctionExpressionType,
+  ClassDeclaration as ClassDeclarationType,
+  DeclareFunction as DeclareFunctionType,
+  ESNode,
+  FunctionTypeAnnotation as FunctionTypeAnnotationType,
+  Identifier as IdentifierType,
+  InterpreterDirective as InterpreterDirectiveType,
+  Token as TokenType,
+  Comment as CommentType,
+  TemplateElement as TemplateElementType,
+  Program as ProgramType,
+  DocblockMetadata as DocblockMetadataType,
+} from 'hermes-estree';
+import type {DetachedNode, MaybeDetachedNode} from '../../detachedNode';
+
+import {
+  asDetachedNode,
+  detachedProps,
+  setParentPointersInDirectChildren,
+} from '../../detachedNode';
+
+/*********************************************************************
+ * this file should only contain one-off variant node type functions *
+ * if you are creating multiple variants for the same "type", then   *
+ * put them in their own file to help keep things organised          *
+ *********************************************************************/
+
+// hermes adds an `id` prop which is always null, and it adds an `expression`
+// boolean which is true when the body isn't a BlockStatement.
+// No need to make consumers set these
+export type ArrowFunctionExpressionProps = {
+  +params: $ReadOnlyArray<
+    MaybeDetachedNode<ArrowFunctionExpressionType['params'][number]>,
+  >,
+  +body: MaybeDetachedNode<ArrowFunctionExpressionType['body']>,
+  +typeParameters?: ?MaybeDetachedNode<
+    ArrowFunctionExpressionType['typeParameters'],
+  >,
+  +returnType?: ?MaybeDetachedNode<ArrowFunctionExpressionType['returnType']>,
+  +predicate?: ?MaybeDetachedNode<ArrowFunctionExpressionType['predicate']>,
+  +async: ArrowFunctionExpressionType['async'],
+};
+export function ArrowFunctionExpression(props: {
+  ...$ReadOnly<ArrowFunctionExpressionProps>,
+  +parent?: ESNode,
+}): DetachedNode<ArrowFunctionExpressionType> {
+  const node = detachedProps<ArrowFunctionExpressionType>(props.parent, {
+    type: 'ArrowFunctionExpression',
+    id: null,
+    // $FlowExpectedError[incompatible-use]
+    expression: props.body.type !== 'BlockStatement',
+    params: props.params.map(n => asDetachedNode(n)),
+    body: asDetachedNode(props.body),
+    typeParameters: asDetachedNode(props.typeParameters),
+    returnType: asDetachedNode(props.returnType),
+    predicate: asDetachedNode(props.predicate),
+    async: props.async,
+  });
+  setParentPointersInDirectChildren(node);
+  return node;
+}
+
+export type ClassDeclarationProps = {
+  +id?: ?MaybeDetachedNode<ClassDeclarationType['id']>,
+  +typeParameters?: ?MaybeDetachedNode<ClassDeclarationType['typeParameters']>,
+  +superClass?: ?MaybeDetachedNode<ClassDeclarationType['superClass']>,
+  +superTypeParameters?: ?MaybeDetachedNode<
+    ClassDeclarationType['superTypeParameters'],
+  >,
+  // make this optional as it's rarer that people would want to include them
+  +implements?: $ReadOnlyArray<
+    MaybeDetachedNode<ClassDeclarationType['implements'][number]>,
+  >,
+  // make this optional as it's rarer that people would want to include them
+  +decorators?: $ReadOnlyArray<
+    MaybeDetachedNode<ClassDeclarationType['decorators'][number]>,
+  >,
+  +body: MaybeDetachedNode<ClassDeclarationType['body']>,
+};
+export function ClassDeclaration(props: {
+  ...$ReadOnly<ClassDeclarationProps>,
+  +parent?: ESNode,
+}): DetachedNode<ClassDeclarationType> {
+  const node = detachedProps<ClassDeclarationType>(props.parent, {
+    type: 'ClassDeclaration',
+    id: asDetachedNode(props.id),
+    typeParameters: asDetachedNode(props.typeParameters),
+    superClass: asDetachedNode(props.superClass),
+    superTypeParameters: asDetachedNode(props.superTypeParameters),
+    decorators: (props.decorators ?? []).map(n => asDetachedNode(n)),
+    implements: (props.implements ?? []).map(n => asDetachedNode(n)),
+    body: asDetachedNode(props.body),
+  });
+  setParentPointersInDirectChildren(node);
+  return node;
+}
+
+// raw/cooked are on a subobject in the estree spec, but are flat on the hermes types
+export type TemplateElementProps = {
+  +tail: TemplateElementType['tail'],
+  +cooked: TemplateElementType['value']['cooked'],
+  +raw: TemplateElementType['value']['raw'],
+};
+export function TemplateElement(props: {
+  ...$ReadOnly<TemplateElementProps>,
+  +parent?: ESNode,
+}): DetachedNode<TemplateElementType> {
+  return detachedProps<TemplateElementType>(props.parent, {
+    type: 'TemplateElement',
+    tail: props.tail,
+    value: {
+      cooked: props.cooked,
+      raw: props.raw,
+    },
+  });
+}
+
+// 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
+export type IdentifierProps = {
+  +name: IdentifierType['name'],
+  +typeAnnotation?: ?MaybeDetachedNode<IdentifierType['typeAnnotation']>,
+  +optional?: IdentifierType['optional'],
+};
+export function Identifier(props: {
+  ...$ReadOnly<IdentifierProps>,
+  +parent?: ESNode,
+}): DetachedNode<IdentifierType> {
+  const node = detachedProps<IdentifierType>(props.parent, {
+    type: 'Identifier',
+    name: props.name,
+    optional: props.optional ?? false,
+    typeAnnotation: asDetachedNode(props.typeAnnotation),
+  });
+  setParentPointersInDirectChildren(node);
+  return node;
+}
+
+export type ProgramProps = {
+  +sourceType: ProgramType['sourceType'],
+  +body: $ReadOnlyArray<MaybeDetachedNode<ProgramType['body'][number]>>,
+  +tokens: $ReadOnlyArray<MaybeDetachedNode<TokenType>>,
+  +comments: $ReadOnlyArray<MaybeDetachedNode<CommentType>>,
+  +interpreter: null | string,
+  +docblock: null | DocblockMetadataType,
+};
+export function Program(props: {
+  ...$ReadOnly<ProgramProps>,
+}): DetachedNode<ProgramType> {
+  return detachedProps<ProgramType>(null, {
+    type: 'Program',
+    sourceType: props.sourceType,
+    body: props.body.map(n => asDetachedNode(n)),
+    tokens: props.tokens,
+    comments: props.comments,
+    interpreter:
+      props.interpreter != null
+        ? // $FlowFixMe[incompatible-call]
+          asDetachedNode<InterpreterDirectiveType>({
+            type: 'InterpreterDirective',
+            value: props.interpreter,
+          })
+        : null,
+    docblock: props.docblock,
+  });
+}
+
+// the type annotation is stored on the Identifier's typeAnnotation
+// which is super awkward to work with and type - so we flatten the input
+// and put it in the right spot after
+export type DeclareFunctionProps = {
+  +name: string,
+  +functionType: MaybeDetachedNode<FunctionTypeAnnotationType>,
+  +predicate?: ?MaybeDetachedNode<DeclareFunctionType['predicate']>,
+};
+export function DeclareFunction(props: {
+  ...$ReadOnly<DeclareFunctionProps>,
+  +parent?: ESNode,
+}): DetachedNode<DeclareFunctionType> {
+  const node = detachedProps<DeclareFunctionType>(props.parent, {
+    type: 'DeclareFunction',
+    id: detachedProps(null, {
+      type: 'Identifier',
+      name: props.name,
+      typeAnnotation: detachedProps(null, {
+        type: 'TypeAnnotation',
+        typeAnnotation: asDetachedNode(props.functionType),
+      }),
+    }),
+    predicate: asDetachedNode(props.predicate),
+  });
+  setParentPointersInDirectChildren(node);
+  return node;
+}

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

@@ -3,191 +3,59 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.ArrowFunctionExpression = ArrowFunctionExpression;
-exports.BigIntLiteral = BigIntLiteral;
-exports.BlockComment = BlockComment;
-exports.BooleanLiteral = BooleanLiteral;
-exports.ClassDeclaration = ClassDeclaration;
-exports.Identifier = Identifier;
-exports.LineComment = LineComment;
-exports.NullLiteral = NullLiteral;
-exports.NumericLiteral = NumericLiteral;
-exports.RegExpLiteral = RegExpLiteral;
-exports.StringLiteral = StringLiteral;
-exports.TemplateElement = TemplateElement;
 
-var _detachedNode = require("../detachedNode");
+var _Comment = require("./special-case-node-types/Comment");
 
-/**
- * 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(props) {
-  const node = (0, _detachedNode.detachedProps)(props.parent, {
-    type: 'ArrowFunctionExpression',
-    id: null,
-    // $FlowExpectedError[incompatible-use]
-    expression: props.body.type !== 'BlockStatement',
-    params: props.params.map(n => (0, _detachedNode.asDetachedNode)(n)),
-    body: (0, _detachedNode.asDetachedNode)(props.body),
-    typeParameters: (0, _detachedNode.asDetachedNode)(props.typeParameters),
-    returnType: (0, _detachedNode.asDetachedNode)(props.returnType),
-    predicate: (0, _detachedNode.asDetachedNode)(props.predicate),
-    async: props.async
-  });
-  (0, _detachedNode.setParentPointersInDirectChildren)(node);
-  return node;
-}
-
-function ClassDeclaration(props) {
-  var _props$decorators, _props$implements;
-
-  const node = (0, _detachedNode.detachedProps)(props.parent, {
-    type: 'ClassDeclaration',
-    id: (0, _detachedNode.asDetachedNode)(props.id),
-    typeParameters: (0, _detachedNode.asDetachedNode)(props.typeParameters),
-    superClass: (0, _detachedNode.asDetachedNode)(props.superClass),
-    superTypeParameters: (0, _detachedNode.asDetachedNode)(props.superTypeParameters),
-    decorators: ((_props$decorators = props.decorators) != null ? _props$decorators : []).map(n => (0, _detachedNode.asDetachedNode)(n)),
-    implements: ((_props$implements = props.implements) != null ? _props$implements : []).map(n => (0, _detachedNode.asDetachedNode)(n)),
-    body: (0, _detachedNode.asDetachedNode)(props.body)
-  });
-  (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(props) {
-  const value = new RegExp(props.pattern, props.flags);
-  return (0, _detachedNode.detachedProps)(props.parent, {
-    type: 'Literal',
-    value,
-    raw: value.toString(),
-    regex: {
-      pattern: props.pattern,
-      flags: props.flags
-    }
-  });
-} // raw/cooked are on a subobject in the estree spec, but are flat on the hermes types
-
-
-function TemplateElement(props) {
-  return (0, _detachedNode.detachedProps)(props.parent, {
-    type: 'TemplateElement',
-    tail: props.tail,
-    value: {
-      cooked: props.cooked,
-      raw: props.raw
-    }
-  });
-} // 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(props) {
-  var _props$optional;
-
-  const node = (0, _detachedNode.detachedProps)(props.parent, {
-    type: 'Identifier',
-    name: props.name,
-    optional: (_props$optional = props.optional) != null ? _props$optional : false,
-    typeAnnotation: (0, _detachedNode.asDetachedNode)(props.typeAnnotation)
-  });
-  (0, _detachedNode.setParentPointersInDirectChildren)(node);
-  return node;
-} //
-// Literals require a "raw" which is added by the estree transform, not hermes.
-//
+Object.keys(_Comment).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _Comment[key]) return;
+  exports[key] = _Comment[key];
+});
 
+var _DeclareExportDeclaration = require("./special-case-node-types/DeclareExportDeclaration");
 
-function BigIntLiteral(props) {
-  var _props$raw;
+Object.keys(_DeclareExportDeclaration).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _DeclareExportDeclaration[key]) return;
+  exports[key] = _DeclareExportDeclaration[key];
+});
 
-  const node = (0, _detachedNode.detachedProps)(props.parent, {
-    type: 'Literal',
-    value: props.value,
-    raw: (_props$raw = props.raw) != null ? _props$raw : `${props.value}n`,
-    bigint: `${props.value}`
-  });
-  (0, _detachedNode.setParentPointersInDirectChildren)(node);
-  return node;
-}
+var _ExportNamedDeclaration = require("./special-case-node-types/ExportNamedDeclaration");
 
-function BooleanLiteral(props) {
-  return (0, _detachedNode.detachedProps)(props.parent, {
-    type: 'Literal',
-    raw: props.value ? 'true' : 'false',
-    value: props.value
-  });
-}
+Object.keys(_ExportNamedDeclaration).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _ExportNamedDeclaration[key]) return;
+  exports[key] = _ExportNamedDeclaration[key];
+});
 
-function NumericLiteral(props) {
-  var _props$raw2;
+var _Literal = require("./special-case-node-types/Literal");
 
-  return (0, _detachedNode.detachedProps)(props.parent, {
-    type: 'Literal',
-    value: props.value,
-    raw: (_props$raw2 = props.raw) != null ? _props$raw2 : `${props.value}`
-  });
-}
+Object.keys(_Literal).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _Literal[key]) return;
+  exports[key] = _Literal[key];
+});
 
-function NullLiteral(props = { ...null
-}) {
-  return (0, _detachedNode.detachedProps)(props.parent, {
-    type: 'Literal',
-    value: null,
-    raw: 'null'
-  });
-}
+var _ObjectTypeProperty = require("./special-case-node-types/ObjectTypeProperty");
 
-function StringLiteral(props) {
-  const hasSingleQuote = props.value.includes('"');
-  const hasDoubleQuote = props.value.includes("'");
-  let raw = props.raw;
+Object.keys(_ObjectTypeProperty).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _ObjectTypeProperty[key]) return;
+  exports[key] = _ObjectTypeProperty[key];
+});
 
-  if (raw == null) {
-    if (hasSingleQuote && hasDoubleQuote) {
-      raw = `'${props.value.replace(/'/g, "\\'")}'`;
-    } else if (hasSingleQuote) {
-      raw = `"${props.value}"`;
-    } else {
-      raw = `'${props.value}'`;
-    }
-  }
+var _misc = require("./special-case-node-types/misc");
 
-  return (0, _detachedNode.detachedProps)(props.parent, {
-    type: 'Literal',
-    raw,
-    value: props.value
-  });
-}
+Object.keys(_misc).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _misc[key]) return;
+  exports[key] = _misc[key];
+});
 
-function LineComment(props) {
-  // $FlowExpectedError[prop-missing]
-  // $FlowExpectedError[incompatible-return]
-  return (0, _detachedNode.detachedProps)(undefined, {
-    type: 'Line',
-    value: props.value
-  });
-}
+var _Property = require("./special-case-node-types/Property");
 
-function BlockComment(props) {
-  // $FlowExpectedError[prop-missing]
-  // $FlowExpectedError[incompatible-return]
-  return (0, _detachedNode.detachedProps)(undefined, {
-    type: 'Block',
-    value: props.value
-  });
-}
+Object.keys(_Property).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _Property[key]) return;
+  exports[key] = _Property[key];
+});