hermes-parser 0.4.6 → 0.6.0

package/dist/HermesParser.js.flow

@@ -0,0 +1,123 @@
+/**
+ * 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
+ * @format
+ */
+
+'use strict';
+
+import type {HermesNode} from './HermesAST';
+import type {ParserOptions} from './ParserOptions';
+
+import HermesParserDeserializer from './HermesParserDeserializer';
+import HermesParserWASM from './HermesParserWASM';
+
+const hermesParse = HermesParserWASM.cwrap('hermesParse', 'number', [
+  'number',
+  'number',
+  'number',
+  'number',
+  'number',
+]);
+
+const hermesParseResult_free = HermesParserWASM.cwrap(
+  'hermesParseResult_free',
+  'void',
+  ['number'],
+);
+
+const hermesParseResult_getError = HermesParserWASM.cwrap(
+  'hermesParseResult_getError',
+  'string',
+  ['number'],
+);
+
+const hermesParseResult_getErrorLine = HermesParserWASM.cwrap(
+  'hermesParseResult_getErrorLine',
+  'number',
+  ['number'],
+);
+
+const hermesParseResult_getErrorColumn = HermesParserWASM.cwrap(
+  'hermesParseResult_getErrorColumn',
+  'number',
+  ['number'],
+);
+
+const hermesParseResult_getProgramBuffer = HermesParserWASM.cwrap(
+  'hermesParseResult_getProgramBuffer',
+  'number',
+  ['number'],
+);
+
+const hermesParseResult_getPositionBuffer = HermesParserWASM.cwrap(
+  'hermesParseResult_getPositionBuffer',
+  'number',
+  ['number'],
+);
+
+const 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;
+}
+
+export function parse(source: string, options: ParserOptions): HermesNode {
+  // 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.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(
+        hermesParseResult_getProgramBuffer(parseResult),
+        hermesParseResult_getPositionBuffer(parseResult),
+        hermesParseResult_getPositionBufferSize(parseResult),
+        HermesParserWASM,
+        options,
+      );
+      return deserializer.deserialize();
+    } finally {
+      hermesParseResult_free(parseResult);
+    }
+  } finally {
+    HermesParserWASM._free(sourceAddr);
+  }
+}

package/dist/HermesParserDecodeUTF8String.js

@@ -1,9 +1,10 @@
 /**
- * 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.
  *
+ * 
  * @format
  */
 'use strict';
@@ -16,13 +17,19 @@
  *   this is technically invalid UTF-8 that UTF8ToString would convert to 0xfffd.
  */
 
-function HermesParserDecodeUTF8String(ptr, length, heap) {
-  var endPtr = ptr + length;
-  var str = '';
+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
-    var u0 = heap[ptr++];
+    let u0 = heap[ptr++];
 
     if (!(u0 & 0x80)) {
       str += String.fromCharCode(u0);
@@ -30,16 +37,16 @@ function HermesParserDecodeUTF8String(ptr, length, heap) {
     } // Two byte code point
 
 
-    var u1 = heap[ptr++] & 0x3f;
+    const u1 = heap[ptr++] & 0x3f;
 
-    if ((u0 & 0xe0) == 0xc0) {
+    if ((u0 & 0xe0) === 0xc0) {
       str += String.fromCharCode((u0 & 0x1f) << 6 | u1);
       continue;
     }
 
-    var u2 = heap[ptr++] & 0x3f;
+    const u2 = heap[ptr++] & 0x3f;
 
-    if ((u0 & 0xf0) == 0xe0) {
+    if ((u0 & 0xf0) === 0xe0) {
       // Three byte code point
       u0 = (u0 & 0x0f) << 12 | u1 << 6 | u2;
     } else {
@@ -58,6 +65,4 @@ function HermesParserDecodeUTF8String(ptr, length, heap) {
   }
 
   return str;
-}
-
-module.exports = HermesParserDecodeUTF8String;
+}

package/dist/HermesParserDecodeUTF8String.js.flow

@@ -0,0 +1,65 @@
+/**
+ * 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
+ * @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.
+ */
+export default function HermesParserDecodeUTF8String(
+  ptrIn: number,
+  length: number,
+  heap: Uint8Array,
+): string {
+  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;
+}

package/dist/HermesParserDeserializer.js

@@ -1,33 +1,39 @@
 /**
- * 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.
  *
+ * 
  * @format
  */
 'use strict';
 
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
-
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
-
-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; }
-
-var HermesParserDecodeUTF8String = require('./HermesParserDecodeUTF8String');
-
-var NODE_DESERIALIZERS = require('./HermesParserNodeDeserializers');
-
-var HermesParserDeserializer = /*#__PURE__*/function () {
-  function HermesParserDeserializer(programBuffer, positionBuffer, positionBufferSize, wasmParser, options) {
-    _classCallCheck(this, HermesParserDeserializer);
-
-    _defineProperty(this, "commentTypes", ['CommentLine', 'CommentBlock', 'InterpreterDirective']);
-
-    _defineProperty(this, "tokenTypes", ['Boolean', 'Identifier', 'Keyword', 'Null', 'Numeric', 'Punctuator', 'String', 'RegularExpression', 'Template', 'JSXText']);
-
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _HermesParserDecodeUTF8String = _interopRequireDefault(require("./HermesParserDecodeUTF8String"));
+
+var _HermesParserNodeDeserializers = _interopRequireDefault(require("./HermesParserNodeDeserializers"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+class HermesParserDeserializer {
+  // Matches StoredComment::Kind enum in JSLexer.h
+  // Matches TokenType enum in HermesParserJSSerializer.h
+  constructor(programBuffer, positionBuffer, positionBufferSize, wasmParser, options) {
+    this.programBufferIdx = void 0;
+    this.positionBufferIdx = void 0;
+    this.positionBufferSize = void 0;
+    this.locMap = void 0;
+    this.HEAPU8 = void 0;
+    this.HEAPU32 = void 0;
+    this.HEAPF64 = void 0;
+    this.options = void 0;
+    this.commentTypes = ['CommentLine', 'CommentBlock', 'InterpreterDirective'];
+    this.tokenTypes = ['Boolean', 'Identifier', 'Keyword', 'Null', 'Numeric', 'BigInt', 'Punctuator', 'String', 'RegularExpression', 'Template', 'JSXText'];
     // Program and position buffer are memory addresses, so we must convert
     // into indices into HEAPU32 (an array of 4-byte integers).
     this.programBufferIdx = programBuffer / 4;
@@ -44,207 +50,194 @@ var HermesParserDeserializer = /*#__PURE__*/function () {
    */
 
 
-  _createClass(HermesParserDeserializer, [{
-    key: "next",
-    value: function next() {
-      var num = this.HEAPU32[this.programBufferIdx++];
-      return num;
-    }
-  }, {
-    key: "deserialize",
-    value: function deserialize() {
-      var program = {
-        type: 'Program',
-        loc: this.addEmptyLoc(),
-        body: this.deserializeNodeList(),
-        comments: this.deserializeComments()
-      };
-
-      if (this.options.tokens) {
-        program.tokens = this.deserializeTokens();
-      }
+  next() {
+    const num = this.HEAPU32[this.programBufferIdx++];
+    return num;
+  }
 
-      this.fillLocs();
-      return program;
-    }
-    /**
-     * Booleans are serialized as a single 4-byte integer.
-     */
-
-  }, {
-    key: "deserializeBoolean",
-    value: function deserializeBoolean() {
-      return Boolean(this.next());
+  deserialize() {
+    const program = {
+      type: 'Program',
+      loc: this.addEmptyLoc(),
+      body: this.deserializeNodeList(),
+      comments: this.deserializeComments()
+    };
+
+    if (this.options.tokens === true) {
+      program.tokens = this.deserializeTokens();
     }
-    /**
-     * Numbers are serialized directly into program buffer, taking up 8 bytes
-     * preceded by 4 bytes of alignment padding if necessary.
-     */
-
-  }, {
-    key: "deserializeNumber",
-    value: function deserializeNumber() {
-      var floatIdx; // Numbers are aligned on 8-byte boundaries, so skip padding if we are at
-      // an odd index into the 4-byte aligned program buffer.
-
-      if (this.programBufferIdx % 2 === 0) {
-        floatIdx = this.programBufferIdx / 2;
-        this.programBufferIdx += 2;
-      } else {
-        floatIdx = (this.programBufferIdx + 1) / 2;
-        this.programBufferIdx += 3;
-      }
 
-      return this.HEAPF64[floatIdx];
+    this.fillLocs();
+    return program;
+  }
+  /**
+   * Booleans are serialized as a single 4-byte integer.
+   */
+
+
+  deserializeBoolean() {
+    return Boolean(this.next());
+  }
+  /**
+   * Numbers are serialized directly into program buffer, taking up 8 bytes
+   * preceded by 4 bytes of alignment padding if necessary.
+   */
+
+
+  deserializeNumber() {
+    let floatIdx; // Numbers are aligned on 8-byte boundaries, so skip padding if we are at
+    // an odd index into the 4-byte aligned program buffer.
+
+    if (this.programBufferIdx % 2 === 0) {
+      floatIdx = this.programBufferIdx / 2;
+      this.programBufferIdx += 2;
+    } else {
+      floatIdx = (this.programBufferIdx + 1) / 2;
+      this.programBufferIdx += 3;
     }
-    /**
-     * Strings are serialized as a 4-byte pointer into the heap, followed
-     * by their size as a 4-byte integer. The size is only present if the
-     * pointer is non-null.
-     */
-
-  }, {
-    key: "deserializeString",
-    value: function deserializeString() {
-      var ptr = this.next();
-
-      if (ptr === 0) {
-        return null;
-      }
 
-      var size = this.next();
-      return HermesParserDecodeUTF8String(ptr, size, this.HEAPU8);
+    return this.HEAPF64[floatIdx];
+  }
+  /**
+   * Strings are serialized as a 4-byte pointer into the heap, followed
+   * by their size as a 4-byte integer. The size is only present if the
+   * pointer is non-null.
+   */
+
+
+  deserializeString() {
+    const ptr = this.next();
+
+    if (ptr === 0) {
+      return null;
     }
-    /**
-     * Nodes are serialized as a 4-byte integer denoting their node kind,
-     * followed by a 4-byte loc ID, followed by serialized node properties.
-     *
-     * If the node kind is 0 the node is null, otherwise the node kind - 1 is an
-     * index into the array of node deserialization functions.
-     */
-
-  }, {
-    key: "deserializeNode",
-    value: function deserializeNode() {
-      var nodeType = this.next();
-
-      if (nodeType === 0) {
-        return null;
-      }
 
-      var nodeDeserializer = NODE_DESERIALIZERS[nodeType - 1].bind(this);
-      return nodeDeserializer();
+    const size = this.next();
+    return (0, _HermesParserDecodeUTF8String.default)(ptr, size, this.HEAPU8);
+  }
+  /**
+   * Nodes are serialized as a 4-byte integer denoting their node kind,
+   * followed by a 4-byte loc ID, followed by serialized node properties.
+   *
+   * If the node kind is 0 the node is null, otherwise the node kind - 1 is an
+   * index into the array of node deserialization functions.
+   */
+
+
+  deserializeNode() {
+    const nodeType = this.next();
+
+    if (nodeType === 0) {
+      return null;
     }
-    /**
-     * Node lists are serialized as a 4-byte integer denoting the number of
-     * elements in the list, followed by the serialized elements.
-     */
-
-  }, {
-    key: "deserializeNodeList",
-    value: function deserializeNodeList() {
-      var size = this.next();
-      var nodeList = [];
-
-      for (var i = 0; i < size; i++) {
-        nodeList.push(this.deserializeNode());
-      }
 
-      return nodeList;
-    } // Matches StoredComment::Kind enum in JSLexer.h
-
-  }, {
-    key: "deserializeComments",
-
-    /**
-     * Comments are serialized as a node list, where each comment is serialized
-     * as a 4-byte integer denoting comment type, followed by a 4-byte value
-     * denoting the loc ID, followed by a serialized string for the comment value.
-     */
-    value: function deserializeComments() {
-      var size = this.next();
-      var comments = [];
-
-      for (var i = 0; i < size; i++) {
-        var commentType = this.commentTypes[this.next()];
-        var loc = this.addEmptyLoc();
-        var value = this.deserializeString();
-        comments.push({
-          type: commentType,
-          loc: loc,
-          value: value
-        });
-      }
+    const nodeDeserializer = _HermesParserNodeDeserializers.default[nodeType - 1].bind(this);
+
+    return nodeDeserializer();
+  }
+  /**
+   * Node lists are serialized as a 4-byte integer denoting the number of
+   * elements in the list, followed by the serialized elements.
+   */
+
 
-      return comments;
+  deserializeNodeList() {
+    const size = this.next();
+    const nodeList = [];
+
+    for (let i = 0; i < size; i++) {
+      nodeList.push(this.deserializeNode());
     }
-  }, {
-    key: "deserializeTokens",
-    value: function deserializeTokens() {
-      var size = this.next();
-      var tokens = [];
-
-      for (var i = 0; i < size; i++) {
-        var tokenType = this.tokenTypes[this.next()];
-        var loc = this.addEmptyLoc();
-        var value = this.deserializeString();
-        tokens.push({
-          type: tokenType,
-          loc: loc,
-          value: value
-        });
-      }
 
-      return tokens;
+    return nodeList;
+  }
+  /**
+   * Comments are serialized as a node list, where each comment is serialized
+   * as a 4-byte integer denoting comment type, followed by a 4-byte value
+   * denoting the loc ID, followed by a serialized string for the comment value.
+   */
+
+
+  deserializeComments() {
+    const size = this.next();
+    const comments = [];
+
+    for (let i = 0; i < size; i++) {
+      const commentType = this.commentTypes[this.next()];
+      const loc = this.addEmptyLoc();
+      const value = this.deserializeString();
+      comments.push({
+        type: commentType,
+        loc,
+        value
+      });
     }
-    /**
-     * While deserializing the AST locations are represented by
-     * a 4-byte loc ID. This is used to create a map of loc IDs to empty loc
-     * objects that are filled after the AST has been deserialized.
-     */
-
-  }, {
-    key: "addEmptyLoc",
-    value: function addEmptyLoc() {
-      var loc = {};
-      this.locMap[this.next()] = loc;
-      return loc;
+
+    return comments;
+  }
+
+  deserializeTokens() {
+    const size = this.next();
+    const tokens = [];
+
+    for (let i = 0; i < size; i++) {
+      const tokenType = this.tokenTypes[this.next()];
+      const loc = this.addEmptyLoc();
+      const value = this.deserializeString();
+      tokens.push({
+        type: tokenType,
+        loc,
+        value
+      });
     }
-    /**
-     * Positions are serialized as a loc ID which denotes which loc it is associated with,
-     * followed by kind which denotes whether it is a start or end position,
-     * followed by line, column, and offset (4-bytes each).
-     */
-
-  }, {
-    key: "fillLocs",
-    value: function fillLocs() {
-      for (var i = 0; i < this.positionBufferSize; i++) {
-        var locId = this.HEAPU32[this.positionBufferIdx++];
-        var kind = this.HEAPU32[this.positionBufferIdx++];
-        var line = this.HEAPU32[this.positionBufferIdx++];
-        var column = this.HEAPU32[this.positionBufferIdx++];
-        var offset = this.HEAPU32[this.positionBufferIdx++];
-        var loc = this.locMap[locId];
-
-        if (kind === 0) {
-          loc.start = {
-            line: line,
-            column: column
-          };
-          loc.rangeStart = offset;
-        } else {
-          loc.end = {
-            line: line,
-            column: column
-          };
-          loc.rangeEnd = offset;
-        }
+
+    return tokens;
+  }
+  /**
+   * While deserializing the AST locations are represented by
+   * a 4-byte loc ID. This is used to create a map of loc IDs to empty loc
+   * objects that are filled after the AST has been deserialized.
+   */
+
+
+  addEmptyLoc() {
+    // $FlowExpectedError
+    const loc = {};
+    this.locMap[this.next()] = loc;
+    return loc;
+  }
+  /**
+   * Positions are serialized as a loc ID which denotes which loc it is associated with,
+   * followed by kind which denotes whether it is a start or end position,
+   * followed by line, column, and offset (4-bytes each).
+   */
+
+
+  fillLocs() {
+    for (let i = 0; i < this.positionBufferSize; i++) {
+      const locId = this.HEAPU32[this.positionBufferIdx++];
+      const kind = this.HEAPU32[this.positionBufferIdx++];
+      const line = this.HEAPU32[this.positionBufferIdx++];
+      const column = this.HEAPU32[this.positionBufferIdx++];
+      const offset = this.HEAPU32[this.positionBufferIdx++];
+      const loc = this.locMap[locId];
+
+      if (kind === 0) {
+        loc.start = {
+          line,
+          column
+        };
+        loc.rangeStart = offset;
+      } else {
+        loc.end = {
+          line,
+          column
+        };
+        loc.rangeEnd = offset;
       }
     }
-  }]);
+  }
 
-  return HermesParserDeserializer;
-}();
+}
 
-module.exports = HermesParserDeserializer;
+exports.default = HermesParserDeserializer;