hermes-parser 0.4.8 → 0.5.0

package/dist/HermesParserDeserializer.js

@@ -4,10 +4,22 @@
  * 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["default"] = void 0;
+
+var _HermesParserDecodeUTF8String = _interopRequireDefault(require("./HermesParserDecodeUTF8String"));
+
+var _HermesParserNodeDeserializers = _interopRequireDefault(require("./HermesParserNodeDeserializers"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
 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); } }
@@ -16,14 +28,28 @@ function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _d
 
 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 () {
+  // Matches StoredComment::Kind enum in JSLexer.h
+  // Matches TokenType enum in HermesParserJSSerializer.h
   function HermesParserDeserializer(programBuffer, positionBuffer, positionBufferSize, wasmParser, options) {
     _classCallCheck(this, HermesParserDeserializer);
 
+    _defineProperty(this, "programBufferIdx", void 0);
+
+    _defineProperty(this, "positionBufferIdx", void 0);
+
+    _defineProperty(this, "positionBufferSize", void 0);
+
+    _defineProperty(this, "locMap", void 0);
+
+    _defineProperty(this, "HEAPU8", void 0);
+
+    _defineProperty(this, "HEAPU32", void 0);
+
+    _defineProperty(this, "HEAPF64", void 0);
+
+    _defineProperty(this, "options", void 0);
+
     _defineProperty(this, "commentTypes", ['CommentLine', 'CommentBlock', 'InterpreterDirective']);
 
     _defineProperty(this, "tokenTypes", ['Boolean', 'Identifier', 'Keyword', 'Null', 'Numeric', 'Punctuator', 'String', 'RegularExpression', 'Template', 'JSXText']);
@@ -60,7 +86,7 @@ var HermesParserDeserializer = /*#__PURE__*/function () {
         comments: this.deserializeComments()
       };
 
-      if (this.options.tokens) {
+      if (this.options.tokens === true) {
         program.tokens = this.deserializeTokens();
       }
 
@@ -113,7 +139,7 @@ var HermesParserDeserializer = /*#__PURE__*/function () {
       }
 
       var size = this.next();
-      return HermesParserDecodeUTF8String(ptr, size, this.HEAPU8);
+      return (0, _HermesParserDecodeUTF8String["default"])(ptr, size, this.HEAPU8);
     }
     /**
      * Nodes are serialized as a 4-byte integer denoting their node kind,
@@ -132,7 +158,8 @@ var HermesParserDeserializer = /*#__PURE__*/function () {
         return null;
       }
 
-      var nodeDeserializer = NODE_DESERIALIZERS[nodeType - 1].bind(this);
+      var nodeDeserializer = _HermesParserNodeDeserializers["default"][nodeType - 1].bind(this);
+
       return nodeDeserializer();
     }
     /**
@@ -151,16 +178,15 @@ var HermesParserDeserializer = /*#__PURE__*/function () {
       }
 
       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.
      */
+
+  }, {
+    key: "deserializeComments",
     value: function deserializeComments() {
       var size = this.next();
       var comments = [];
@@ -206,6 +232,7 @@ var HermesParserDeserializer = /*#__PURE__*/function () {
   }, {
     key: "addEmptyLoc",
     value: function addEmptyLoc() {
+      // $FlowExpectedError
       var loc = {};
       this.locMap[this.next()] = loc;
       return loc;
@@ -247,4 +274,4 @@ var HermesParserDeserializer = /*#__PURE__*/function () {
   return HermesParserDeserializer;
 }();
 
-module.exports = HermesParserDeserializer;
+exports["default"] = HermesParserDeserializer;

package/dist/HermesParserDeserializer.js.flow

@@ -0,0 +1,260 @@
+/**
+ * Copyright (c) Facebook, Inc. and its 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 {
+  HermesSourceLocation,
+  HermesNode,
+  HermesToken,
+  HermesComment,
+} from './HermesAST';
+import typeof HermesParserWASM from './HermesParserWASM';
+import type {ParserOptions} from './ParserOptions';
+
+import HermesParserDecodeUTF8String from './HermesParserDecodeUTF8String';
+import NODE_DESERIALIZERS from './HermesParserNodeDeserializers';
+
+export default class HermesParserDeserializer {
+  programBufferIdx: number;
+  positionBufferIdx: number;
+  +positionBufferSize: number;
+  +locMap: {[number]: HermesSourceLocation};
+  +HEAPU8: HermesParserWASM['HEAPU8'];
+  +HEAPU32: HermesParserWASM['HEAPU32'];
+  +HEAPF64: HermesParserWASM['HEAPF64'];
+  +options: ParserOptions;
+
+  // Matches StoredComment::Kind enum in JSLexer.h
+  +commentTypes: $ReadOnlyArray<HermesComment['type']> = [
+    'CommentLine',
+    'CommentBlock',
+    'InterpreterDirective',
+  ];
+
+  // Matches TokenType enum in HermesParserJSSerializer.h
+  +tokenTypes: $ReadOnlyArray<HermesToken['type']> = [
+    'Boolean',
+    'Identifier',
+    'Keyword',
+    'Null',
+    'Numeric',
+    'Punctuator',
+    'String',
+    'RegularExpression',
+    'Template',
+    'JSXText',
+  ];
+
+  constructor(
+    programBuffer: number,
+    positionBuffer: number,
+    positionBufferSize: number,
+    wasmParser: HermesParserWASM,
+    options: ParserOptions,
+  ) {
+    // 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;
+    this.positionBufferIdx = positionBuffer / 4;
+
+    this.positionBufferSize = positionBufferSize;
+    this.locMap = {};
+
+    this.HEAPU8 = wasmParser.HEAPU8;
+    this.HEAPU32 = wasmParser.HEAPU32;
+    this.HEAPF64 = wasmParser.HEAPF64;
+
+    this.options = options;
+  }
+
+  /**
+   * Consume and return the next 4 bytes in the program buffer.
+   */
+  next(): number {
+    const num = this.HEAPU32[this.programBufferIdx++];
+    return num;
+  }
+
+  deserialize(): HermesNode {
+    const program: HermesNode = {
+      type: 'Program',
+      loc: this.addEmptyLoc(),
+      body: this.deserializeNodeList(),
+      comments: this.deserializeComments(),
+    };
+
+    if (this.options.tokens === true) {
+      program.tokens = this.deserializeTokens();
+    }
+
+    this.fillLocs();
+
+    return program;
+  }
+
+  /**
+   * Booleans are serialized as a single 4-byte integer.
+   */
+  deserializeBoolean(): boolean {
+    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(): number {
+    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;
+    }
+
+    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(): ?string {
+    const ptr = this.next();
+    if (ptr === 0) {
+      return null;
+    }
+
+    const size = this.next();
+
+    return HermesParserDecodeUTF8String(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(): ?HermesNode {
+    const nodeType = this.next();
+    if (nodeType === 0) {
+      return null;
+    }
+
+    const nodeDeserializer = NODE_DESERIALIZERS[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.
+   */
+  deserializeNodeList(): Array<?HermesNode> {
+    const size = this.next();
+    const nodeList = [];
+
+    for (let i = 0; i < size; i++) {
+      nodeList.push(this.deserializeNode());
+    }
+
+    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(): Array<HermesComment> {
+    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,
+      });
+    }
+
+    return comments;
+  }
+
+  deserializeTokens(): Array<HermesToken> {
+    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,
+      });
+    }
+
+    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(): HermesSourceLocation {
+    // $FlowExpectedError
+    const loc: HermesSourceLocation = {};
+    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(): void {
+    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;
+      }
+    }
+  }
+}

package/dist/HermesParserNodeDeserializers.js

@@ -4,6 +4,7 @@
  * 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';
@@ -703,7 +704,7 @@ function deserializeImportDeclaration() {
     loc: this.addEmptyLoc(),
     specifiers: this.deserializeNodeList(),
     source: this.deserializeNode(),
-    attributes: this.deserializeNodeList(),
+    assertions: this.deserializeNodeList(),
     importKind: this.deserializeString()
   };
 }

package/dist/HermesParserNodeDeserializers.js.flow

@@ -0,0 +1,16 @@
+/**
+ * Copyright (c) Facebook, Inc. and its 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
+ */
+
+import type {HermesNode} from './HermesAST';
+import type HermesParserDeserializer from './HermesParserDeserializer';
+
+declare module.exports: $ReadOnlyArray<
+  (this: HermesParserDeserializer) => HermesNode,
+>;