hermes-parser 0.4.8 → 0.5.0

package/dist/HermesParserWASM.js.flow

@@ -0,0 +1,75 @@
+/**
+ * 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
+ */
+
+type INTENTIONAL_ANY = $FlowFixMe;
+type JSType = 'number' | 'string' | 'array' | 'boolean';
+type CBoolean = ?(number | boolean);
+
+type HermesParserWASM = $ReadOnly<{
+  HEAP8: Int8Array,
+  HEAP16: Int16Array,
+  HEAP32: Int32Array,
+  HEAPU8: Uint8Array,
+  HEAPU16: Uint16Array,
+  HEAPU32: Uint32Array,
+  HEAPF32: Float32Array,
+  HEAPF64: Float64Array,
+
+  _malloc(size: number): number,
+  _free(ptr: number): void,
+
+  ccall(
+    ident: string,
+    returnType: JSType | null,
+    argTypes: $ReadOnlyArray<JSType>,
+    args: $ReadOnlyArray<
+      number | string | $ReadOnlyArray<INTENTIONAL_ANY> | boolean,
+    >,
+    opts?: $ReadOnly<{
+      async?: boolean | void,
+    }>,
+  ): INTENTIONAL_ANY,
+  cwrap: {
+    (
+      'hermesParse',
+      'number',
+      ['number', 'number', 'number', 'number', 'number'],
+    ): (number, number, CBoolean, CBoolean, CBoolean) => number,
+    ('hermesParseResult_free', 'void', ['number']): number => void,
+    ('hermesParseResult_getError', 'string', ['number']): number => string,
+    ('hermesParseResult_getErrorLine', 'number', ['number']): number => number,
+    (
+      'hermesParseResult_getErrorColumn',
+      'number',
+      ['number'],
+    ): number => number,
+    (
+      'hermesParseResult_getProgramBuffer',
+      'number',
+      ['number'],
+    ): number => number,
+    (
+      'hermesParseResult_getPositionBuffer',
+      'number',
+      ['number'],
+    ): number => number,
+    (
+      'hermesParseResult_getPositionBufferSize',
+      'number',
+      ['number'],
+    ): number => number,
+  },
+
+  stackAlloc(size: number): number,
+  stackSave(): number,
+  stackRestore(ptr: number): void,
+}>;
+
+declare module.exports: HermesParserWASM;

package/dist/HermesToBabelAdapter.js

@@ -1,16 +1,19 @@
-/**
- * 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";
 
 function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
 
-function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _HermesASTAdapter2 = _interopRequireDefault(require("./HermesASTAdapter"));
+
+var _excluded = ["comments"];
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
 
 function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
 
@@ -32,16 +35,14 @@ function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || func
 
 function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
 
-function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
 
 function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
 
-function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
 
 function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
 
-var HermesASTAdapter = require('./HermesASTAdapter');
-
 var HermesToBabelAdapter = /*#__PURE__*/function (_HermesASTAdapter) {
   _inherits(HermesToBabelAdapter, _HermesASTAdapter);
 
@@ -148,7 +149,7 @@ var HermesToBabelAdapter = /*#__PURE__*/function (_HermesASTAdapter) {
       // Visit child nodes and convert to directives
       var _this$mapNodeWithDire = this.mapNodeWithDirectives(node),
           comments = _this$mapNodeWithDire.comments,
-          program = _objectWithoutProperties(_this$mapNodeWithDire, ["comments"]);
+          program = _objectWithoutProperties(_this$mapNodeWithDire, _excluded);
 
       program.sourceType = this.getSourceType(); // Adjust start loc to beginning of file
 
@@ -440,6 +441,6 @@ var HermesToBabelAdapter = /*#__PURE__*/function (_HermesASTAdapter) {
   }]);
 
   return HermesToBabelAdapter;
-}(HermesASTAdapter);
+}(_HermesASTAdapter2["default"]);
 
-module.exports = HermesToBabelAdapter;
+exports["default"] = HermesToBabelAdapter;

package/dist/HermesToBabelAdapter.js.flow

@@ -0,0 +1,368 @@
+/**
+ * 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 HermesASTAdapter from './HermesASTAdapter';
+
+export default class HermesToBabelAdapter extends HermesASTAdapter {
+  fixSourceLocation(node: HermesNode): void {
+    const loc = node.loc;
+    if (loc == null) {
+      return;
+    }
+
+    node.loc = {
+      source: this.sourceFilename ?? null,
+      start: loc.start,
+      end: loc.end,
+    };
+
+    node.start = loc.rangeStart;
+    node.end = loc.rangeEnd;
+  }
+
+  mapNode(node: HermesNode): HermesNode {
+    this.fixSourceLocation(node);
+    switch (node.type) {
+      case 'Program':
+        return this.mapProgram(node);
+      case 'BlockStatement':
+        return this.mapNodeWithDirectives(node);
+      case 'Empty':
+        return this.mapEmpty(node);
+      case 'Identifier':
+        return this.mapIdentifier(node);
+      case 'TemplateElement':
+        return this.mapTemplateElement(node);
+      case 'GenericTypeAnnotation':
+        return this.mapGenericTypeAnnotation(node);
+      case 'SymbolTypeAnnotation':
+        return this.mapSymbolTypeAnnotation(node);
+      case 'Property':
+        return this.mapProperty(node);
+      case 'MethodDefinition':
+        return this.mapMethodDefinition(node);
+      case 'ImportDeclaration':
+        return this.mapImportDeclaration(node);
+      case 'ImportSpecifier':
+        return this.mapImportSpecifier(node);
+      case 'ExportDefaultDeclaration':
+        return this.mapExportDefaultDeclaration(node);
+      case 'ExportNamedDeclaration':
+        return this.mapExportNamedDeclaration(node);
+      case 'ExportAllDeclaration':
+        return this.mapExportAllDeclaration(node);
+      case 'RestElement':
+        return this.mapRestElement(node);
+      case 'ImportExpression':
+        return this.mapImportExpression(node);
+      case 'PrivateName':
+      case 'ClassPrivateProperty':
+        return this.mapPrivateProperty(node);
+      case 'FunctionDeclaration':
+      case 'FunctionExpression':
+        return this.mapFunction(node);
+      case 'IndexedAccessType':
+      case 'OptionalIndexedAccessType':
+        return this.mapUnsupportedTypeAnnotation(node);
+      default:
+        return this.mapNodeDefault(node);
+    }
+  }
+
+  mapProgram(node: HermesNode): HermesNode {
+    // Visit child nodes and convert to directives
+    const {comments, ...program} = this.mapNodeWithDirectives(node);
+
+    program.sourceType = this.getSourceType();
+
+    // Adjust start loc to beginning of file
+    program.loc.start = {line: 1, column: 0};
+    program.start = 0;
+
+    // Adjust end loc to include last comment if program ends with a comment
+    if (comments.length > 0) {
+      const lastComment = comments[comments.length - 1];
+      if (lastComment.end > program.end) {
+        program.loc.end = lastComment.loc.end;
+        program.end = lastComment.end;
+      }
+    }
+
+    // Rename root node to File node and move Program node under program property
+    return {
+      type: 'File',
+      loc: program.loc,
+      start: program.start,
+      end: program.end,
+      program,
+      comments,
+    };
+  }
+
+  mapNodeWithDirectives(node: HermesNode): HermesNode {
+    const directives = [];
+    for (const child of node.body) {
+      if (child.type === 'ExpressionStatement' && child.directive != null) {
+        // Visit directive children
+        const directiveChild = this.mapNode(child);
+
+        // Modify string literal node to be DirectiveLiteral node
+        directiveChild.expression.type = 'DirectiveLiteral';
+
+        // Construct Directive node with DirectiveLiteral value
+        directives.push({
+          type: 'Directive',
+          loc: directiveChild.loc,
+          start: directiveChild.start,
+          end: directiveChild.end,
+          value: directiveChild.expression,
+        });
+      } else {
+        // Once we have found the first non-directive node we know there cannot be any more directives
+        break;
+      }
+    }
+
+    // Move directives from body to new directives array
+    node.directives = directives;
+    if (directives.length !== 0) {
+      node.body = node.body.slice(directives.length);
+    }
+
+    // Visit expression statement children
+    const body = node.body;
+    for (let i = 0; i < body.length; i++) {
+      const child = body[i];
+      if (child != null) {
+        body[i] = this.mapNode(child);
+      }
+    }
+
+    return node;
+  }
+
+  mapIdentifier(node: HermesNode): HermesNode {
+    node.loc.identifierName = node.name;
+    return this.mapNodeDefault(node);
+  }
+
+  mapTemplateElement(node: HermesNode): HermesNode {
+    // Adjust start loc to exclude "`" at beginning of template literal if this is the first quasi,
+    // otherwise exclude "}" from previous expression.
+    const startCharsToExclude = 1;
+
+    // Adjust end loc to exclude "`" at end of template literal if this is the last quasi,
+    // otherwise exclude "${" from next expression.
+    const endCharsToExclude = node.tail ? 1 : 2;
+
+    return {
+      type: 'TemplateElement',
+      loc: {
+        start: {
+          line: node.loc.start.line,
+          column: node.loc.start.column + startCharsToExclude,
+        },
+        end: {
+          line: node.loc.end.line,
+          column: node.loc.end.column - endCharsToExclude,
+        },
+      },
+      start: node.start + startCharsToExclude,
+      end: node.end - endCharsToExclude,
+      tail: node.tail,
+      value: {
+        cooked: node.cooked,
+        raw: node.raw,
+      },
+    };
+  }
+
+  mapGenericTypeAnnotation(node: HermesNode): HermesNode {
+    // Convert simple `this` generic type to ThisTypeAnnotation
+    if (
+      node.typeParameters === null &&
+      node.id.type === 'Identifier' &&
+      node.id.name === 'this'
+    ) {
+      return {
+        type: 'ThisTypeAnnotation',
+        loc: node.loc,
+        start: node.start,
+        end: node.end,
+      };
+    }
+
+    return this.mapNodeDefault(node);
+  }
+
+  mapSymbolTypeAnnotation(node: HermesNode): HermesNode {
+    return {
+      type: 'GenericTypeAnnotation',
+      loc: node.loc,
+      start: node.start,
+      end: node.end,
+      id: {
+        type: 'Identifier',
+        loc: node.loc,
+        start: node.start,
+        end: node.end,
+        name: 'symbol',
+      },
+      typeParameters: null,
+    };
+  }
+
+  mapProperty(node: HermesNode): HermesNode {
+    const key = this.mapNode(node.key);
+    const value = this.mapNode(node.value);
+
+    // Convert methods, getters, and setters to ObjectMethod nodes
+    if (node.method || node.kind !== 'init') {
+      // Properties under the FunctionExpression value that should be moved
+      // to the ObjectMethod node itself.
+      const {
+        id,
+        params,
+        body,
+        async,
+        generator,
+        returnType,
+        typeParameters,
+        predicate,
+      } = value;
+
+      return {
+        type: 'ObjectMethod',
+        loc: node.loc,
+        start: node.start,
+        end: node.end,
+        // Non getter or setter methods have `kind = method`
+        kind: node.kind === 'init' ? 'method' : node.kind,
+        computed: node.computed,
+        key,
+        id,
+        params,
+        body,
+        async,
+        generator,
+        returnType,
+        typeParameters,
+        predicate,
+      };
+    } else {
+      // Non-method property nodes should be renamed to ObjectProperty
+      node.type = 'ObjectProperty';
+      return node;
+    }
+  }
+
+  mapMethodDefinition(node: HermesNode): HermesNode {
+    const key = this.mapNode(node.key);
+    const value = this.mapNode(node.value);
+
+    // Properties under the FunctionExpression value that should be moved
+    // to the ClassMethod node itself.
+    const {
+      id,
+      params,
+      body,
+      async,
+      generator,
+      returnType,
+      typeParameters,
+      predicate,
+    } = value;
+
+    return {
+      type: 'ClassMethod',
+      loc: node.loc,
+      start: node.start,
+      end: node.end,
+      kind: node.kind,
+      computed: node.computed,
+      static: node.static,
+      key,
+      id,
+      params,
+      body,
+      async,
+      generator,
+      returnType,
+      typeParameters,
+      predicate,
+    };
+  }
+
+  mapRestElement(node: HermesNode): HermesNode {
+    const restElement = this.mapNodeDefault(node);
+
+    // Hermes puts type annotations on rest elements on the argument node,
+    // but Babel expects type annotations on the rest element node itself.
+    const annotation = restElement.argument.typeAnnotation;
+    if (annotation != null) {
+      restElement.typeAnnotation = annotation;
+      restElement.argument.typeAnnotation = null;
+    }
+
+    return restElement;
+  }
+
+  mapImportExpression(node: HermesNode): HermesNode {
+    // Babel expects ImportExpression to be structued as a regular
+    // CallExpression where the callee is an Import node.
+    return {
+      type: 'CallExpression',
+      loc: node.loc,
+      start: node.start,
+      end: node.end,
+      callee: {
+        type: 'Import',
+        loc: node.loc,
+        start: node.start,
+        end: node.end,
+      },
+      arguments: [this.mapNode(node.source)],
+    };
+  }
+
+  mapFunction(node: HermesNode): HermesNode {
+    // Remove the first parameter if it is a this-type annotation,
+    // which is not recognized by Babel.
+    if (node.params.length !== 0 && node.params[0].name === 'this') {
+      node.params.shift();
+    }
+
+    return this.mapNodeDefault(node);
+  }
+
+  /**
+   * If Babel (the version we target) does not support a type annotation we
+   * parse, we need to return some other valid type annotation in its place.
+   */
+  mapUnsupportedTypeAnnotation(node: HermesNode): HermesNode {
+    return {
+      type: 'AnyTypeAnnotation',
+      loc: node.loc,
+      start: node.start,
+      end: node.end,
+    };
+  }
+}

package/dist/HermesToESTreeAdapter.js

@@ -1,15 +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.
- *
- * @format
- */
-'use strict';
+"use strict";
 
 function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
 
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _HermesASTAdapter2 = _interopRequireDefault(require("./HermesASTAdapter"));
+
+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); } }
@@ -22,15 +23,15 @@ function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || func
 
 function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
 
-function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
 
 function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
 
-function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
 
 function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
 
-var HermesASTAdapter = require('./HermesASTAdapter');
+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 HermesToESTreeAdapter = /*#__PURE__*/function (_HermesASTAdapter) {
   _inherits(HermesToESTreeAdapter, _HermesASTAdapter);
@@ -43,6 +44,9 @@ var HermesToESTreeAdapter = /*#__PURE__*/function (_HermesASTAdapter) {
     _classCallCheck(this, HermesToESTreeAdapter);
 
     _this = _super.call(this, options);
+
+    _defineProperty(_assertThisInitialized(_this), "code", void 0);
+
     _this.code = code;
     return _this;
   }
@@ -207,6 +211,6 @@ var HermesToESTreeAdapter = /*#__PURE__*/function (_HermesASTAdapter) {
   }]);
 
   return HermesToESTreeAdapter;
-}(HermesASTAdapter);
+}(_HermesASTAdapter2["default"]);
 
-module.exports = HermesToESTreeAdapter;
+exports["default"] = HermesToESTreeAdapter;