hermes-parser 0.28.0 → 0.29.0

package/dist/HermesToESTreeAdapter.js

@@ -116,6 +116,9 @@ class HermesToESTreeAdapter extends _HermesASTAdapter.default {
       case 'OptionalCallExpression':
         return this.mapChainExpression(node);
 
+      case 'BlockStatement':
+        return this.mapBlockStatement(node);
+
       default:
         return this.mapNodeDefault(node);
     }
@@ -436,6 +439,15 @@ class HermesToESTreeAdapter extends _HermesASTAdapter.default {
     return node;
   }
 
+  mapBlockStatement(node) {
+    if (node.implicit && node.body.length) {
+      return this.mapNode(node.body[0]);
+    }
+
+    delete node.implicit;
+    return this.mapNodeDefault(node);
+  }
+
 }
 
 exports.default = HermesToESTreeAdapter;

package/dist/HermesToESTreeAdapter.js.flow

@@ -92,6 +92,8 @@ export default class HermesToESTreeAdapter extends HermesASTAdapter {
       case 'CallExpression':
       case 'OptionalCallExpression':
         return this.mapChainExpression(node);
+      case 'BlockStatement':
+        return this.mapBlockStatement(node);
       default:
         return this.mapNodeDefault(node);
     }
@@ -424,4 +426,12 @@ export default class HermesToESTreeAdapter extends HermesASTAdapter {
     node.exported = node.exported ?? null;
     return node;
   }
+
+  mapBlockStatement(node: HermesNode): HermesNode {
+    if (node.implicit && node.body.length) {
+      return this.mapNode(node.body[0]);
+    }
+    delete node.implicit;
+    return this.mapNodeDefault(node);
+  }
 }

package/dist/babel/TransformESTreeToBabel.js.flow

@@ -406,26 +406,28 @@ function mapProgram(node: Program): BabelFile {
   };
   const range = [0, endRange];
 
-  const babelComments = program.comments.map(comment => {
-    switch (comment.type) {
-      case 'Line': {
-        return {
-          type: 'CommentLine',
-          value: comment.value,
-          loc: comment.loc,
-          range: comment.range,
-        };
+  const babelComments: $ReadOnlyArray<BabelComment> = program.comments.map(
+    comment => {
+      switch (comment.type) {
+        case 'Line': {
+          return {
+            type: 'CommentLine',
+            value: comment.value,
+            loc: comment.loc,
+            range: comment.range,
+          };
+        }
+        case 'Block': {
+          return {
+            type: 'CommentBlock',
+            value: comment.value,
+            loc: comment.loc,
+            range: comment.range,
+          };
+        }
       }
-      case 'Block': {
-        return {
-          type: 'CommentBlock',
-          value: comment.value,
-          loc: comment.loc,
-          range: comment.range,
-        };
-      }
-    }
-  });
+    },
+  );
 
   // Rename root node to File node and move Program node under program property
   return {

package/dist/estree/StripComponentSyntax.js.flow

@@ -32,6 +32,7 @@ import type {
   SourceLocation,
   Position,
   ObjectPattern,
+  ObjectTypeAnnotation,
   Identifier,
   Range,
   RestElement,
@@ -139,7 +140,7 @@ function createPropsTypeAnnotation(
     typeProperties.unshift(spread);
   }
 
-  const propTypeObj = {
+  const propTypeObj: ObjectTypeAnnotation = {
     type: 'ObjectTypeAnnotation',
     callProperties: [],
     properties: typeProperties,
@@ -238,7 +239,7 @@ function mapComponentParameters(
 
   const propsProperties = paramsWithoutRef.flatMap(mapComponentParameter);
 
-  let props = null;
+  let props: null | ObjectPattern | Identifier = null;
   if (propsProperties.length === 0) {
     if (refParam == null) {
       throw new Error(
@@ -460,7 +461,7 @@ type ForwardRefDetails = {
 function createForwardRefWrapper(
   originalComponent: ComponentDeclaration,
 ): ForwardRefDetails {
-  const internalCompId = {
+  const internalCompId: Identifier = {
     type: 'Identifier',
     name: `${originalComponent.id.name}_withRef`,
     optional: false,
@@ -578,7 +579,7 @@ function mapComponentDeclaration(
     forwardRefDetails = createForwardRefWrapper(node);
   }
 
-  const comp = {
+  const comp: FunctionDeclaration = {
     type: 'FunctionDeclaration',
     id:
       forwardRefDetails != null
@@ -636,7 +637,7 @@ function mapDeclareHook(node: DeclareHook): DeclareFunction {
 }
 
 function mapHookDeclaration(node: HookDeclaration): FunctionDeclaration {
-  const comp = {
+  const comp: FunctionDeclaration = {
     type: 'FunctionDeclaration',
     id: node.id && shallowCloneNode(node.id),
     __hookDeclaration: true,

package/dist/estree/TransformMatchSyntax.js

@@ -551,23 +551,12 @@ function testsOfCondition(root, condition) {
 
     case 'object':
       {
-        // typeof <x> === 'object' && <x> !== null
+        // (typeof <x> === 'object' && <x> !== null) || typeof <x> === 'function'
         const {
           key
         } = condition;
-        const typeofObject = {
-          type: 'BinaryExpression',
-          left: {
-            type: 'UnaryExpression',
-            operator: 'typeof',
-            argument: expressionOfKey(root, key),
-            prefix: true,
-            ...(0, _Builders.etc)()
-          },
-          right: (0, _Builders.stringLiteral)('object'),
-          operator: '===',
-          ...(0, _Builders.etc)()
-        };
+        const typeofObject = (0, _Builders.typeofExpression)(expressionOfKey(root, key), 'object');
+        const typeofFunction = (0, _Builders.typeofExpression)(expressionOfKey(root, key), 'function');
         const notNull = {
           type: 'BinaryExpression',
           left: expressionOfKey(root, key),
@@ -575,7 +564,7 @@ function testsOfCondition(root, condition) {
           operator: '!==',
           ...(0, _Builders.etc)()
         };
-        return [typeofObject, notNull];
+        return [(0, _Builders.disjunction)([(0, _Builders.conjunction)([typeofObject, notNull]), typeofFunction])];
       }
 
     case 'prop-exists':

package/dist/estree/TransformMatchSyntax.js.flow

@@ -18,6 +18,7 @@ import type {ParserOptions} from '../ParserOptions';
 import type {
   BinaryExpression,
   BreakStatement,
+  DestructuringObjectProperty,
   ESNode,
   Expression,
   Identifier,
@@ -53,6 +54,7 @@ import {
   numberLiteral,
   stringLiteral,
   throwStatement,
+  typeofExpression,
   variableDeclaration,
 } from '../utils/Builders';
 import {createGenID} from '../utils/GenID';
@@ -279,7 +281,7 @@ function analyzePattern(
       const [id, kind] =
         target.type === 'MatchBindingPattern'
           ? [target.id, target.kind]
-          : [target, 'const'];
+          : [target, ('const': 'const')];
       checkDuplicateBindingName(seenBindingNames, pattern, id.name);
       checkBindingKind(pattern, kind);
       const binding: Binding = {type: 'id', key, kind, id};
@@ -476,29 +478,26 @@ function testsOfCondition(
       return [isArray, lengthCheck];
     }
     case 'object': {
-      // typeof <x> === 'object' && <x> !== null
+      // (typeof <x> === 'object' && <x> !== null) || typeof <x> === 'function'
       const {key} = condition;
-      const typeofObject: BinaryExpression = {
-        type: 'BinaryExpression',
-        left: {
-          type: 'UnaryExpression',
-          operator: 'typeof',
-          argument: expressionOfKey(root, key),
-          prefix: true,
-          ...etc(),
-        },
-        right: stringLiteral('object'),
-        operator: '===',
-        ...etc(),
-      };
-      const notNull = {
+      const typeofObject = typeofExpression(
+        expressionOfKey(root, key),
+        'object',
+      );
+      const typeofFunction = typeofExpression(
+        expressionOfKey(root, key),
+        'function',
+      );
+      const notNull: BinaryExpression = {
         type: 'BinaryExpression',
         left: expressionOfKey(root, key),
         right: nullLiteral(),
         operator: '!==',
         ...etc(),
       };
-      return [typeofObject, notNull];
+      return [
+        disjunction([conjunction([typeofObject, notNull]), typeofFunction]),
+      ];
     }
     case 'prop-exists': {
       // <propName> in <x>
@@ -563,7 +562,7 @@ function statementsOfBindings(
         const destructuring: ObjectPattern = {
           type: 'ObjectPattern',
           properties: exclude
-            .map(prop =>
+            .map((prop): DestructuringObjectProperty =>
               prop.type === 'Identifier'
                 ? {
                     type: 'Property',
@@ -737,7 +736,7 @@ function mapMatchExpression(node: MatchExpression): Expression {
   // If the original argument is simple, no need for a new variable.
   const statements: Array<Statement> = analyses.map(
     ({conditions, bindings, guard, body}) => {
-      const returnNode = {
+      const returnNode: Statement = {
         type: 'ReturnStatement',
         argument: body,
         ...etc(),

package/dist/generated/ESTreeVisitorKeys.js

@@ -104,7 +104,7 @@ module.exports = {
   ImportAttribute: ['key', 'value'],
   ImportDeclaration: ['specifiers', 'source', 'assertions'],
   ImportDefaultSpecifier: ['local'],
-  ImportExpression: ['source', 'attributes'],
+  ImportExpression: ['source', 'options'],
   ImportNamespaceSpecifier: ['local'],
   ImportSpecifier: ['imported', 'local'],
   IndexedAccessType: ['objectType', 'indexType'],

package/dist/generated/ParserVisitorKeys.js

@@ -370,7 +370,7 @@ const HERMES_AST_VISITOR_KEYS = {
   },
   ImportExpression: {
     source: 'Node',
-    attributes: 'Node'
+    options: 'Node'
   },
   ImportNamespaceSpecifier: {
     local: 'Node'

package/dist/index.js.flow

@@ -24,7 +24,7 @@ import * as TransformESTreeToBabel from './babel/TransformESTreeToBabel';
 import * as StripFlowTypes from './estree/StripFlowTypes';
 
 const DEFAULTS = {
-  flow: 'detect',
+  flow: ('detect': 'detect'),
 };
 
 function getOptions(options?: ParserOptions = {...DEFAULTS}) {

package/dist/src/HermesASTAdapter.js

@@ -0,0 +1,192 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _ParserVisitorKeys = require("./generated/ParserVisitorKeys");
+
+/**
+ * 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
+ */
+
+/**
+ * The base class for transforming the Hermes AST to the desired output format.
+ * Extended by concrete adapters which output an ESTree or Babel AST.
+ */
+class HermesASTAdapter {
+  constructor(options) {
+    this.sourceFilename = void 0;
+    this.sourceType = void 0;
+    this.sourceFilename = options.sourceFilename;
+    this.sourceType = options.sourceType;
+  }
+  /**
+   * Transform the input Hermes AST to the desired output format.
+   * This modifies the input AST in place instead of constructing a new AST.
+   */
+
+
+  transform(program) {
+    // Comments are not traversed via visitor keys
+    const comments = program.comments;
+
+    for (let i = 0; i < comments.length; i++) {
+      const comment = comments[i];
+      this.fixSourceLocation(comment);
+      comments[i] = this.mapComment(comment);
+    } // The first comment may be an interpreter directive and is stored directly on the program node
+
+
+    program.interpreter = comments.length > 0 && comments[0].type === 'InterpreterDirective' ? comments.shift() : null; // Tokens are not traversed via visitor keys
+
+    const tokens = program.tokens;
+
+    if (tokens) {
+      for (let i = 0; i < tokens.length; i++) {
+        this.fixSourceLocation(tokens[i]);
+      }
+    }
+
+    const resultNode = this.mapNode(program);
+
+    if (resultNode.type !== 'Program') {
+      throw new Error(`HermesToESTreeAdapter: Must return a Program node, instead of "${resultNode.type}". `);
+    } // $FlowExpectedError[incompatible-return] We know this is a program at this point.
+
+
+    return resultNode;
+  }
+  /**
+   * Transform a Hermes AST node to the output AST format.
+   *
+   * This may modify the input node in-place and return that same node, or a completely
+   * new node may be constructed and returned. Overriden in child classes.
+   */
+
+
+  mapNode(_node) {
+    throw new Error('Implemented in subclasses');
+  }
+
+  mapNodeDefault(node) {
+    const visitorKeys = _ParserVisitorKeys.HERMES_AST_VISITOR_KEYS[node.type];
+
+    for (const key in visitorKeys) {
+      const childType = visitorKeys[key];
+
+      if (childType === _ParserVisitorKeys.NODE_CHILD) {
+        const child = node[key];
+
+        if (child != null) {
+          node[key] = this.mapNode(child);
+        }
+      } else if (childType === _ParserVisitorKeys.NODE_LIST_CHILD) {
+        const children = node[key];
+
+        for (let i = 0; i < children.length; i++) {
+          const child = children[i];
+
+          if (child != null) {
+            children[i] = this.mapNode(child);
+          }
+        }
+      }
+    }
+
+    return node;
+  }
+  /**
+   * Update the source location for this node depending on the output AST format.
+   * This can modify the input node in-place. Overriden in child classes.
+   */
+
+
+  fixSourceLocation(_node) {
+    throw new Error('Implemented in subclasses');
+  }
+
+  getSourceType() {
+    var _this$sourceType;
+
+    return (_this$sourceType = this.sourceType) != null ? _this$sourceType : 'script';
+  }
+
+  setModuleSourceType() {
+    if (this.sourceType == null) {
+      this.sourceType = 'module';
+    }
+  }
+
+  mapComment(node) {
+    return node;
+  }
+
+  mapEmpty(_node) {
+    // $FlowExpectedError
+    return null;
+  }
+
+  mapImportDeclaration(node) {
+    if (node.importKind === 'value') {
+      this.setModuleSourceType();
+    }
+
+    return this.mapNodeDefault(node);
+  }
+
+  mapImportSpecifier(node) {
+    if (node.importKind === 'value') {
+      node.importKind = null;
+    }
+
+    return this.mapNodeDefault(node);
+  }
+
+  mapExportDefaultDeclaration(node) {
+    this.setModuleSourceType();
+    return this.mapNodeDefault(node);
+  }
+
+  mapExportNamedDeclaration(node) {
+    if (node.exportKind === 'value') {
+      this.setModuleSourceType();
+    }
+
+    return this.mapNodeDefault(node);
+  }
+
+  mapExportAllDeclaration(node) {
+    if (node.exportKind === 'value') {
+      this.setModuleSourceType();
+    }
+
+    return this.mapNodeDefault(node);
+  }
+
+  formatError(node, message) {
+    return `${message} (${node.loc.start.line}:${node.loc.start.column})`;
+  }
+
+  getBigIntLiteralValue(bigintString) {
+    const bigint = bigintString // estree spec is to not have a trailing `n` on this property
+    // https://github.com/estree/estree/blob/db962bb417a97effcfe9892f87fbb93c81a68584/es2020.md#bigintliteral
+    .replace(/n$/, '') // `BigInt` doesn't accept numeric separator and `bigint` property should not include numeric separator
+    .replaceAll('_', '');
+    return {
+      bigint,
+      // coerce the string to a bigint value if supported by the environment
+      value: typeof BigInt === 'function' ? BigInt(bigint) : null
+    };
+  }
+
+}
+
+exports.default = HermesASTAdapter;

package/dist/src/HermesParser.js

@@ -0,0 +1,108 @@
+/**
+ * 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';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.parse = parse;
+
+var _HermesParserDeserializer = _interopRequireDefault(require("./HermesParserDeserializer"));
+
+var _HermesParserWASM = _interopRequireDefault(require("./HermesParserWASM"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+let HermesParserWASM;
+let hermesParse;
+let hermesParseResult_free;
+let hermesParseResult_getError;
+let hermesParseResult_getErrorLine;
+let hermesParseResult_getErrorColumn;
+let hermesParseResult_getProgramBuffer;
+let hermesParseResult_getPositionBuffer;
+let hermesParseResult_getPositionBufferSize;
+/**
+ * Init the WASM wrapper code generated by `emscripten` to preparse the
+ * HermesParser WASM code.
+ */
+
+function initHermesParserWASM() {
+  if (HermesParserWASM != null) {
+    return;
+  }
+
+  HermesParserWASM = (0, _HermesParserWASM.default)({
+    /**
+     * The emscripten version of `quit` unconditionally assigns the `status` to
+     * `process.exitCode` which overrides any pre-existing code that has been
+     * set, even if it is non zero. For our use case we never want an
+     * `exitCode` to be set so this override removes that functionality.
+     */
+    quit(_status, toThrow) {
+      throw toThrow;
+    }
+
+  });
+  hermesParse = HermesParserWASM.cwrap('hermesParse', 'number', ['number', 'number', 'number', 'number', 'number', 'number', 'number']);
+  hermesParseResult_free = HermesParserWASM.cwrap('hermesParseResult_free', 'void', ['number']);
+  hermesParseResult_getError = HermesParserWASM.cwrap('hermesParseResult_getError', 'string', ['number']);
+  hermesParseResult_getErrorLine = HermesParserWASM.cwrap('hermesParseResult_getErrorLine', 'number', ['number']);
+  hermesParseResult_getErrorColumn = HermesParserWASM.cwrap('hermesParseResult_getErrorColumn', 'number', ['number']);
+  hermesParseResult_getProgramBuffer = HermesParserWASM.cwrap('hermesParseResult_getProgramBuffer', 'number', ['number']);
+  hermesParseResult_getPositionBuffer = HermesParserWASM.cwrap('hermesParseResult_getPositionBuffer', 'number', ['number']);
+  hermesParseResult_getPositionBufferSize = HermesParserWASM.cwrap('hermesParseResult_getPositionBufferSize', 'number', ['number']);
+} // Copy a string into the WASM heap and null-terminate
+
+
+function copyToHeap(buffer, addr) {
+  HermesParserWASM.HEAP8.set(buffer, addr);
+  HermesParserWASM.HEAP8[addr + buffer.length] = 0;
+}
+
+function parse(source, options) {
+  initHermesParserWASM(); // Allocate space on heap for source text
+
+  const sourceBuffer = Buffer.from(source, 'utf8');
+
+  const sourceAddr = HermesParserWASM._malloc(sourceBuffer.length + 1);
+
+  if (!sourceAddr) {
+    throw new Error('Parser out of memory');
+  }
+
+  try {
+    // Copy source text onto WASM heap
+    copyToHeap(sourceBuffer, sourceAddr);
+    const parseResult = hermesParse(sourceAddr, sourceBuffer.length + 1, options.flow === 'detect', options.enableExperimentalComponentSyntax, options.enableExperimentalFlowMatchSyntax, options.tokens, options.allowReturnOutsideFunction);
+
+    try {
+      // Extract and throw error from parse result if parsing failed
+      const err = hermesParseResult_getError(parseResult);
+
+      if (err) {
+        const syntaxError = new SyntaxError(err); // $FlowExpectedError[prop-missing]
+
+        syntaxError.loc = {
+          line: hermesParseResult_getErrorLine(parseResult),
+          column: hermesParseResult_getErrorColumn(parseResult)
+        };
+        throw syntaxError;
+      }
+
+      const deserializer = new _HermesParserDeserializer.default(hermesParseResult_getProgramBuffer(parseResult), hermesParseResult_getPositionBuffer(parseResult), hermesParseResult_getPositionBufferSize(parseResult), HermesParserWASM, options);
+      return deserializer.deserialize();
+    } finally {
+      hermesParseResult_free(parseResult);
+    }
+  } finally {
+    HermesParserWASM._free(sourceAddr);
+  }
+}

package/dist/src/HermesParserDecodeUTF8String.js

@@ -0,0 +1,68 @@
+/**
+ * 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';
+/**
+ * Decode a UTF-8 encoded string from Hermes with a known length.
+ * Based on Emscripten's UTF8ToString with the following differences:
+ * - Always reads all bytes up to the given length, including null bytes. This
+ *   means that we can decode strings that contain null bytes in the middle.
+ * - Allow UTF-8 encoded code points that are part of a surrogate pair, even though
+ *   this is technically invalid UTF-8 that UTF8ToString would convert to 0xfffd.
+ */
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = HermesParserDecodeUTF8String;
+
+function HermesParserDecodeUTF8String(ptrIn, length, heap) {
+  let ptr = ptrIn;
+  const endPtr = ptr + length;
+  let str = '';
+
+  while (ptr < endPtr) {
+    // ASCII characters fit in single byte code point
+    let u0 = heap[ptr++];
+
+    if (!(u0 & 0x80)) {
+      str += String.fromCharCode(u0);
+      continue;
+    } // Two byte code point
+
+
+    const u1 = heap[ptr++] & 0x3f;
+
+    if ((u0 & 0xe0) === 0xc0) {
+      str += String.fromCharCode((u0 & 0x1f) << 6 | u1);
+      continue;
+    }
+
+    const u2 = heap[ptr++] & 0x3f;
+
+    if ((u0 & 0xf0) === 0xe0) {
+      // Three byte code point
+      u0 = (u0 & 0x0f) << 12 | u1 << 6 | u2;
+    } else {
+      // Four byte code point
+      u0 = (u0 & 0x07) << 18 | u1 << 12 | u2 << 6 | heap[ptr++] & 0x3f;
+    }
+
+    if (u0 < 0x10000) {
+      // Code point fits into a single UTF-16 code unit
+      str += String.fromCharCode(u0);
+    } else {
+      // Code point does not fit into single UTF-16 code unit so convert to surrogate pair
+      u0 -= 0x10000;
+      str += String.fromCharCode(0xd800 | u0 >> 10, 0xdc00 | u0 & 0x3ff);
+    }
+  }
+
+  return str;
+}