hermes-parser 0.4.8 → 0.5.0

package/dist/HermesAST.js.flow

@@ -0,0 +1,56 @@
+/**
+ * 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
+ */
+
+// flowlint unclear-type:off
+
+export interface HermesPosition {
+  /** >= 1 */
+  +line: number;
+  /** >= 0 */
+  +column: number;
+}
+export type HermesSourceLocation = {
+  start?: HermesPosition,
+  end?: HermesPosition,
+  rangeStart?: number,
+  rangeEnd?: number,
+};
+export type HermesNode = {
+  type: string,
+  [string]: any,
+};
+export type HermesToken = {
+  type:
+    | 'Boolean'
+    | 'Identifier'
+    | 'Keyword'
+    | 'Null'
+    | 'Numeric'
+    | 'Punctuator'
+    | 'String'
+    | 'RegularExpression'
+    | 'Template'
+    | 'JSXText',
+  loc: HermesSourceLocation,
+  value: ?string,
+};
+export type HermesComment = {
+  type: 'CommentLine' | 'CommentBlock' | 'InterpreterDirective',
+  loc: HermesSourceLocation,
+  value: ?string,
+};
+export type HermesProgram = {
+  type: 'Program',
+  loc: HermesSourceLocation,
+  body: Array<?HermesNode>,
+  comments: Array<HermesComment>,
+  tokens?: Array<HermesToken>,
+  interpreter?: ?HermesComment,
+};

package/dist/HermesASTAdapter.js

@@ -1,12 +1,11 @@
-/**
- * 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.
- *
- * @format
- */
-'use strict';
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _visitorKeys = require("./generated/visitor-keys");
 
 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
@@ -14,20 +13,20 @@ function _defineProperties(target, props) { for (var i = 0; i < props.length; i+
 
 function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
 
-var _require = require('./HermesParserVisitorKeys'),
-    HERMES_AST_VISITOR_KEYS = _require.HERMES_AST_VISITOR_KEYS,
-    NODE_CHILD = _require.NODE_CHILD,
-    NODE_LIST_CHILD = _require.NODE_LIST_CHILD;
+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; }
+
 /**
  * The base class for transforming the Hermes AST to the desired output format.
  * Extended by concrete adapters which output an ESTree or Babel AST.
  */
-
-
 var HermesASTAdapter = /*#__PURE__*/function () {
-  function HermesASTAdapter(options, code) {
+  function HermesASTAdapter(options) {
     _classCallCheck(this, HermesASTAdapter);
 
+    _defineProperty(this, "sourceFilename", void 0);
+
+    _defineProperty(this, "sourceType", void 0);
+
     this.sourceFilename = options.sourceFilename;
     this.sourceType = options.sourceType;
   }
@@ -71,25 +70,24 @@ var HermesASTAdapter = /*#__PURE__*/function () {
 
   }, {
     key: "mapNode",
-    value: function mapNode(node) {
-      this.fixSourceLocation(node);
-      return this.mapNodeDefault(node);
+    value: function mapNode(_node) {
+      throw new Error('Implemented in subclasses');
     }
   }, {
     key: "mapNodeDefault",
     value: function mapNodeDefault(node) {
-      var visitorKeys = HERMES_AST_VISITOR_KEYS[node.type];
+      var visitorKeys = _visitorKeys.HERMES_AST_VISITOR_KEYS[node.type];
 
       for (var key in visitorKeys) {
         var childType = visitorKeys[key];
 
-        if (childType === NODE_CHILD) {
+        if (childType === _visitorKeys.NODE_CHILD) {
           var child = node[key];
 
           if (child != null) {
             node[key] = this.mapNode(child);
           }
-        } else if (childType === NODE_LIST_CHILD) {
+        } else if (childType === _visitorKeys.NODE_LIST_CHILD) {
           var children = node[key];
 
           for (var i = 0; i < children.length; i++) {
@@ -111,7 +109,7 @@ var HermesASTAdapter = /*#__PURE__*/function () {
 
   }, {
     key: "fixSourceLocation",
-    value: function fixSourceLocation(node) {
+    value: function fixSourceLocation(_node) {
       throw new Error('Implemented in subclasses');
     }
   }, {
@@ -135,7 +133,8 @@ var HermesASTAdapter = /*#__PURE__*/function () {
     }
   }, {
     key: "mapEmpty",
-    value: function mapEmpty(node) {
+    value: function mapEmpty(_node) {
+      // $FlowExpectedError
       return null;
     }
   }, {
@@ -195,4 +194,4 @@ var HermesASTAdapter = /*#__PURE__*/function () {
   return HermesASTAdapter;
 }();
 
-module.exports = HermesASTAdapter;
+exports["default"] = HermesASTAdapter;

package/dist/HermesASTAdapter.js.flow

@@ -0,0 +1,178 @@
+/**
+ * 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
+ * @format
+ */
+
+/*
+This class does some very "javascripty" things in the name of
+performance which are ultimately impossible to soundly type.
+
+So instead of adding strict types and a large number of suppression
+comments, instead it is left untyped and subclasses are strictly
+typed via a separate flow declaration file.
+*/
+
+import type {HermesNode} from './HermesAST';
+import type {ParserOptions} from './ParserOptions';
+
+import {
+  HERMES_AST_VISITOR_KEYS,
+  NODE_CHILD,
+  NODE_LIST_CHILD,
+} from './generated/visitor-keys';
+
+/**
+ * The base class for transforming the Hermes AST to the desired output format.
+ * Extended by concrete adapters which output an ESTree or Babel AST.
+ */
+export default class HermesASTAdapter {
+  sourceFilename: ParserOptions['sourceFilename'];
+  sourceType: ParserOptions['sourceType'];
+
+  constructor(options: ParserOptions) {
+    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: HermesNode): ?HermesNode {
+    // 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]);
+      }
+    }
+
+    return this.mapNode(program);
+  }
+
+  /**
+   * 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: HermesNode): HermesNode {
+    throw new Error('Implemented in subclasses');
+  }
+
+  mapNodeDefault(node: HermesNode): HermesNode {
+    const visitorKeys = HERMES_AST_VISITOR_KEYS[node.type];
+    for (const key in visitorKeys) {
+      const childType = visitorKeys[key];
+      if (childType === NODE_CHILD) {
+        const child = node[key];
+        if (child != null) {
+          node[key] = this.mapNode(child);
+        }
+      } else if (childType === 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: HermesNode): void {
+    throw new Error('Implemented in subclasses');
+  }
+
+  getSourceType(): ParserOptions['sourceType'] {
+    return this.sourceType ?? 'script';
+  }
+
+  setModuleSourceType(): void {
+    if (this.sourceType == null) {
+      this.sourceType = 'module';
+    }
+  }
+
+  mapComment(node: HermesNode): HermesNode {
+    return node;
+  }
+
+  mapEmpty(_node: HermesNode): HermesNode {
+    // $FlowExpectedError
+    return null;
+  }
+
+  mapImportDeclaration(node: HermesNode): HermesNode {
+    if (node.importKind === 'value') {
+      this.setModuleSourceType();
+    }
+
+    return this.mapNodeDefault(node);
+  }
+
+  mapImportSpecifier(node: HermesNode): HermesNode {
+    if (node.importKind === 'value') {
+      node.importKind = null;
+    }
+
+    return this.mapNodeDefault(node);
+  }
+
+  mapExportDefaultDeclaration(node: HermesNode): HermesNode {
+    this.setModuleSourceType();
+    return this.mapNodeDefault(node);
+  }
+
+  mapExportNamedDeclaration(node: HermesNode): HermesNode {
+    if (node.exportKind === 'value') {
+      this.setModuleSourceType();
+    }
+
+    return this.mapNodeDefault(node);
+  }
+
+  mapExportAllDeclaration(node: HermesNode): HermesNode {
+    if (node.exportKind === 'value') {
+      this.setModuleSourceType();
+    }
+
+    return this.mapNodeDefault(node);
+  }
+
+  mapPrivateProperty(node: HermesNode): HermesNode {
+    throw new SyntaxError(
+      this.formatError(node, 'Private properties are not supported'),
+    );
+  }
+
+  formatError(node: HermesNode, message: string): string {
+    return `${message} (${node.loc.start.line}:${node.loc.start.column})`;
+  }
+}

package/dist/HermesParser.js

@@ -4,33 +4,50 @@
  * 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';
 
-var HermesParserDeserializer = require('./HermesParserDeserializer');
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.parse = parse;
 
-var HermesParserWASM = require('./HermesParserWASM');
+var _HermesParserDeserializer = _interopRequireDefault(require("./HermesParserDeserializer"));
+
+var _HermesParserWASM = _interopRequireDefault(require("./HermesParserWASM"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+var hermesParse = _HermesParserWASM["default"].cwrap('hermesParse', 'number', ['number', 'number', 'number', 'number', 'number']);
+
+var hermesParseResult_free = _HermesParserWASM["default"].cwrap('hermesParseResult_free', 'void', ['number']);
+
+var hermesParseResult_getError = _HermesParserWASM["default"].cwrap('hermesParseResult_getError', 'string', ['number']);
+
+var hermesParseResult_getErrorLine = _HermesParserWASM["default"].cwrap('hermesParseResult_getErrorLine', 'number', ['number']);
+
+var hermesParseResult_getErrorColumn = _HermesParserWASM["default"].cwrap('hermesParseResult_getErrorColumn', 'number', ['number']);
+
+var hermesParseResult_getProgramBuffer = _HermesParserWASM["default"].cwrap('hermesParseResult_getProgramBuffer', 'number', ['number']);
+
+var hermesParseResult_getPositionBuffer = _HermesParserWASM["default"].cwrap('hermesParseResult_getPositionBuffer', 'number', ['number']);
+
+var hermesParseResult_getPositionBufferSize = _HermesParserWASM["default"].cwrap('hermesParseResult_getPositionBufferSize', 'number', ['number']); // Copy a string into the WASM heap and null-terminate
 
-var hermesParse = HermesParserWASM.cwrap('hermesParse', 'number', ['number', 'number', 'number', 'number', 'number']);
-var hermesParseResult_free = HermesParserWASM.cwrap('hermesParseResult_free', 'void', ['number']);
-var hermesParseResult_getError = HermesParserWASM.cwrap('hermesParseResult_getError', 'string', ['number']);
-var hermesParseResult_getErrorLine = HermesParserWASM.cwrap('hermesParseResult_getErrorLine', 'number', ['number']);
-var hermesParseResult_getErrorColumn = HermesParserWASM.cwrap('hermesParseResult_getErrorColumn', 'number', ['number']);
-var hermesParseResult_getProgramBuffer = HermesParserWASM.cwrap('hermesParseResult_getProgramBuffer', 'number', ['number']);
-var hermesParseResult_getPositionBuffer = HermesParserWASM.cwrap('hermesParseResult_getPositionBuffer', 'number', ['number']);
-var 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;
+  _HermesParserWASM["default"].HEAP8.set(buffer, addr);
+
+  _HermesParserWASM["default"].HEAP8[addr + buffer.length] = 0;
 }
 
 function parse(source, options) {
   // Allocate space on heap for source text
   var sourceBuffer = Buffer.from(source, 'utf8');
 
-  var sourceAddr = HermesParserWASM._malloc(sourceBuffer.length + 1);
+  var sourceAddr = _HermesParserWASM["default"]._malloc(sourceBuffer.length + 1);
 
   if (!sourceAddr) {
     throw new Error('Parser out of memory');
@@ -46,7 +63,8 @@ function parse(source, options) {
       var err = hermesParseResult_getError(parseResult);
 
       if (err) {
-        var syntaxError = new SyntaxError(err);
+        var syntaxError = new SyntaxError(err); // $FlowExpectedError[prop-missing]
+
         syntaxError.loc = {
           line: hermesParseResult_getErrorLine(parseResult),
           column: hermesParseResult_getErrorColumn(parseResult)
@@ -54,16 +72,12 @@ function parse(source, options) {
         throw syntaxError;
       }
 
-      var deserializer = new HermesParserDeserializer(hermesParseResult_getProgramBuffer(parseResult), hermesParseResult_getPositionBuffer(parseResult), hermesParseResult_getPositionBufferSize(parseResult), HermesParserWASM, options);
+      var deserializer = new _HermesParserDeserializer["default"](hermesParseResult_getProgramBuffer(parseResult), hermesParseResult_getPositionBuffer(parseResult), hermesParseResult_getPositionBufferSize(parseResult), _HermesParserWASM["default"], options);
       return deserializer.deserialize();
     } finally {
       hermesParseResult_free(parseResult);
     }
   } finally {
-    HermesParserWASM._free(sourceAddr);
+    _HermesParserWASM["default"]._free(sourceAddr);
   }
-}
-
-module.exports = {
-  parse: parse
-};
+}

package/dist/HermesParser.js.flow

@@ -0,0 +1,123 @@
+/**
+ * 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 {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

@@ -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';
@@ -16,7 +17,13 @@
  *   this is technically invalid UTF-8 that UTF8ToString would convert to 0xfffd.
  */
 
-function HermesParserDecodeUTF8String(ptr, length, heap) {
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = HermesParserDecodeUTF8String;
+
+function HermesParserDecodeUTF8String(ptrIn, length, heap) {
+  var ptr = ptrIn;
   var endPtr = ptr + length;
   var str = '';
 
@@ -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) 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';
+
+/**
+ * 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;
+}