hermes-parser 0.7.0 → 0.8.0

package/dist/HermesToBabelAdapter.js

@@ -89,6 +89,9 @@ class HermesToBabelAdapter extends _HermesASTAdapter.default {
       case 'ExportNamedDeclaration':
         return this.mapExportNamedDeclaration(node);
 
+      case 'ExportNamespaceSpecifier':
+        return this.mapExportNamespaceSpecifier(node);
+
       case 'ExportAllDeclaration':
         return this.mapExportAllDeclaration(node);
 
@@ -102,6 +105,8 @@ class HermesToBabelAdapter extends _HermesASTAdapter.default {
         return this.mapJSXStringLiteral(node);
 
       case 'PrivateName':
+        return this.mapPrivateName(node);
+
       case 'ClassPrivateProperty':
         return this.mapPrivateProperty(node);
 
@@ -113,6 +118,9 @@ class HermesToBabelAdapter extends _HermesASTAdapter.default {
       case 'OptionalIndexedAccessType':
         return this.mapUnsupportedTypeAnnotation(node);
 
+      case 'BigIntLiteral':
+        return this.mapBigIntLiteral(node);
+
       default:
         return this.mapNodeDefault(node);
     }
@@ -278,13 +286,14 @@ class HermesToBabelAdapter extends _HermesASTAdapter.default {
         typeParameters,
         predicate
       } = value;
-      return {
+      const newNode = {
         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,
+        method: node.kind === 'init' ? true : false,
         computed: node.computed,
         key,
         id,
@@ -296,6 +305,13 @@ class HermesToBabelAdapter extends _HermesASTAdapter.default {
         typeParameters,
         predicate
       };
+
+      if (node.kind !== 'init') {
+        // babel emits an empty variance property on accessors for some reason
+        newNode.variance = null;
+      }
+
+      return newNode;
     } else {
       // Non-method property nodes should be renamed to ObjectProperty
       node.type = 'ObjectProperty';
@@ -346,7 +362,15 @@ class HermesToBabelAdapter extends _HermesASTAdapter.default {
 
     if (annotation != null) {
       restElement.typeAnnotation = annotation;
-      restElement.argument.typeAnnotation = null;
+      restElement.argument.typeAnnotation = null; // Unfortunately there's no way for us to recover the end location of
+      // the argument for the general case
+
+      if (restElement.argument.type === 'Identifier') {
+        restElement.argument.end = restElement.argument.start + restElement.argument.name.length;
+        restElement.argument.loc.end = { ...restElement.argument.loc.start,
+          column: restElement.argument.loc.start.column + restElement.argument.name.length
+        };
+      }
     }
 
     return restElement;
@@ -362,9 +386,13 @@ class HermesToBabelAdapter extends _HermesASTAdapter.default {
       end: node.end,
       callee: {
         type: 'Import',
-        loc: node.loc,
+        loc: { ...node.loc,
+          end: { ...node.loc.start,
+            column: node.loc.start.column + 'import'.length
+          }
+        },
         start: node.start,
-        end: node.end
+        end: node.start + 'import'.length
       },
       arguments: [this.mapNode(node.source)]
     };
@@ -407,6 +435,57 @@ class HermesToBabelAdapter extends _HermesASTAdapter.default {
     };
   }
 
+  mapBigIntLiteral(node) {
+    const bigint = node.bigint.replace(/n$/, '').replace(/_/, '');
+    node.value = typeof BigInt === 'function' ? BigInt(bigint) : null;
+    return node;
+  }
+
+  mapPrivateProperty(nodeUnprocessed) {
+    const node = this.mapNodeDefault(nodeUnprocessed);
+    node.key = {
+      type: 'PrivateName',
+      id: { ...node.key,
+        // babel doesn't include the hash in the identifier
+        start: node.key.start + 1,
+        loc: { ...node.key.loc,
+          start: { ...node.key.loc.start,
+            column: node.key.loc.start.column + 1
+          }
+        }
+      },
+      start: node.key.start,
+      end: node.key.end,
+      loc: node.key.loc
+    };
+    return node;
+  }
+
+  mapPrivateName(node) {
+    // babel doesn't include the hash in the identifier
+    node.id.start += 1;
+    node.id.loc.start.column += 1;
+    return node;
+  }
+
+  mapExportNamespaceSpecifier(nodeUnprocessed) {
+    const node = this.mapNodeDefault(nodeUnprocessed); // the hermes AST emits the location as the location of the entire export
+    // but babel emits the location as *just* the "* as id" bit
+    // the end will always align with the end of the identifier (ezpz)
+    // but the start will align with the "*" token - which we can't recover from just the AST
+    // so we just fudge the start location a bit to get it "good enough"
+    // it will be wrong if the AST is anything like "export      * as x from 'y'"... but oh well
+
+    node.start = node.start + 'export '.length;
+    node.loc.start.column = node.loc.start.column + 'export '.length;
+    node.end = node.exported.end;
+    node.loc.end = {
+      column: node.exported.loc.end.column,
+      line: node.exported.loc.end.line
+    };
+    return node;
+  }
+
 }
 
 exports.default = HermesToBabelAdapter;

package/dist/HermesToBabelAdapter.js.flow

@@ -21,6 +21,8 @@ import type {HermesNode} from './HermesAST';
 
 import HermesASTAdapter from './HermesASTAdapter';
 
+declare var BigInt: ?(value: $FlowFixMe) => mixed;
+
 export default class HermesToBabelAdapter extends HermesASTAdapter {
   fixSourceLocation(node: HermesNode): void {
     const loc = node.loc;
@@ -67,6 +69,8 @@ export default class HermesToBabelAdapter extends HermesASTAdapter {
         return this.mapExportDefaultDeclaration(node);
       case 'ExportNamedDeclaration':
         return this.mapExportNamedDeclaration(node);
+      case 'ExportNamespaceSpecifier':
+        return this.mapExportNamespaceSpecifier(node);
       case 'ExportAllDeclaration':
         return this.mapExportAllDeclaration(node);
       case 'RestElement':
@@ -76,6 +80,7 @@ export default class HermesToBabelAdapter extends HermesASTAdapter {
       case 'JSXStringLiteral':
         return this.mapJSXStringLiteral(node);
       case 'PrivateName':
+        return this.mapPrivateName(node);
       case 'ClassPrivateProperty':
         return this.mapPrivateProperty(node);
       case 'FunctionDeclaration':
@@ -84,6 +89,8 @@ export default class HermesToBabelAdapter extends HermesASTAdapter {
       case 'IndexedAccessType':
       case 'OptionalIndexedAccessType':
         return this.mapUnsupportedTypeAnnotation(node);
+      case 'BigIntLiteral':
+        return this.mapBigIntLiteral(node);
       default:
         return this.mapNodeDefault(node);
     }
@@ -251,13 +258,14 @@ export default class HermesToBabelAdapter extends HermesASTAdapter {
         predicate,
       } = value;
 
-      return {
+      const newNode: HermesNode = {
         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,
+        method: node.kind === 'init' ? true : false,
         computed: node.computed,
         key,
         id,
@@ -269,6 +277,11 @@ export default class HermesToBabelAdapter extends HermesASTAdapter {
         typeParameters,
         predicate,
       };
+      if (node.kind !== 'init') {
+        // babel emits an empty variance property on accessors for some reason
+        newNode.variance = null;
+      }
+      return newNode;
     } else {
       // Non-method property nodes should be renamed to ObjectProperty
       node.type = 'ObjectProperty';
@@ -322,6 +335,18 @@ export default class HermesToBabelAdapter extends HermesASTAdapter {
     if (annotation != null) {
       restElement.typeAnnotation = annotation;
       restElement.argument.typeAnnotation = null;
+      // Unfortunately there's no way for us to recover the end location of
+      // the argument for the general case
+      if (restElement.argument.type === 'Identifier') {
+        restElement.argument.end =
+          restElement.argument.start + restElement.argument.name.length;
+        restElement.argument.loc.end = {
+          ...restElement.argument.loc.start,
+          column:
+            restElement.argument.loc.start.column +
+            restElement.argument.name.length,
+        };
+      }
     }
 
     return restElement;
@@ -337,9 +362,15 @@ export default class HermesToBabelAdapter extends HermesASTAdapter {
       end: node.end,
       callee: {
         type: 'Import',
-        loc: node.loc,
+        loc: {
+          ...node.loc,
+          end: {
+            ...node.loc.start,
+            column: node.loc.start.column + 'import'.length,
+          },
+        },
         start: node.start,
-        end: node.end,
+        end: node.start + 'import'.length,
       },
       arguments: [this.mapNode(node.source)],
     };
@@ -380,4 +411,62 @@ export default class HermesToBabelAdapter extends HermesASTAdapter {
       end: node.end,
     };
   }
+
+  mapBigIntLiteral(node: HermesNode): HermesNode {
+    const bigint = node.bigint.replace(/n$/, '').replace(/_/, '');
+    node.value = typeof BigInt === 'function' ? BigInt(bigint) : null;
+    return node;
+  }
+
+  mapPrivateProperty(nodeUnprocessed: HermesNode): HermesNode {
+    const node = this.mapNodeDefault(nodeUnprocessed);
+    node.key = {
+      type: 'PrivateName',
+      id: {
+        ...node.key,
+        // babel doesn't include the hash in the identifier
+        start: node.key.start + 1,
+        loc: {
+          ...node.key.loc,
+          start: {
+            ...node.key.loc.start,
+            column: node.key.loc.start.column + 1,
+          },
+        },
+      },
+      start: node.key.start,
+      end: node.key.end,
+      loc: node.key.loc,
+    };
+
+    return node;
+  }
+
+  mapPrivateName(node: HermesNode): HermesNode {
+    // babel doesn't include the hash in the identifier
+    node.id.start += 1;
+    node.id.loc.start.column += 1;
+    return node;
+  }
+
+  mapExportNamespaceSpecifier(nodeUnprocessed: HermesNode): HermesNode {
+    const node = this.mapNodeDefault(nodeUnprocessed);
+
+    // the hermes AST emits the location as the location of the entire export
+    // but babel emits the location as *just* the "* as id" bit
+
+    // the end will always align with the end of the identifier (ezpz)
+    // but the start will align with the "*" token - which we can't recover from just the AST
+    // so we just fudge the start location a bit to get it "good enough"
+    // it will be wrong if the AST is anything like "export      * as x from 'y'"... but oh well
+    node.start = node.start + 'export '.length;
+    node.loc.start.column = node.loc.start.column + 'export '.length;
+    node.end = node.exported.end;
+    node.loc.end = {
+      column: node.exported.loc.end.column,
+      line: node.exported.loc.end.line,
+    };
+
+    return node;
+  }
 }

package/dist/HermesToESTreeAdapter.js

@@ -7,6 +7,8 @@ exports.default = void 0;
 
 var _HermesASTAdapter = _interopRequireDefault(require("./HermesASTAdapter"));
 
+var _getModuleDocblock = require("./getModuleDocblock");
+
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 /**
@@ -49,6 +51,8 @@ class HermesToESTreeAdapter extends _HermesASTAdapter.default {
       end: loc.end
     };
     node.range = [loc.rangeStart, loc.rangeEnd];
+    delete node.start;
+    delete node.end;
   }
 
   mapNode(node) {
@@ -100,12 +104,26 @@ class HermesToESTreeAdapter extends _HermesASTAdapter.default {
       case 'ExportAllDeclaration':
         return this.mapExportAllDeclaration(node);
 
+      case 'Property':
+        return this.mapProperty(node);
+
+      case 'FunctionDeclaration':
+      case 'FunctionExpression':
+      case 'ArrowFunctionExpression':
+        return this.mapFunction(node);
+
       case 'PrivateName':
+        return this.mapPrivateName(node);
+
+      case 'ClassProperty':
       case 'ClassPrivateProperty':
-        return this.mapPrivateProperty(node);
+        return this.mapClassProperty(node);
 
-      case 'Property':
-        return this.mapProperty(node);
+      case 'MemberExpression':
+      case 'OptionalMemberExpression':
+      case 'CallExpression':
+      case 'OptionalCallExpression':
+        return this.mapChainExpression(node);
 
       default:
         return this.mapNodeDefault(node);
@@ -115,6 +133,7 @@ class HermesToESTreeAdapter extends _HermesASTAdapter.default {
   mapProgram(node) {
     node = this.mapNodeDefault(node);
     node.sourceType = this.getSourceType();
+    node.docblock = (0, _getModuleDocblock.getModuleDocblock)(node);
     return node;
   }
 
@@ -246,6 +265,189 @@ class HermesToESTreeAdapter extends _HermesASTAdapter.default {
     return node;
   }
 
+  mapFunction(nodeUnprocessed) {
+    const node = this.mapNodeDefault(nodeUnprocessed);
+
+    switch (node.type) {
+      case 'FunctionDeclaration':
+      case 'FunctionExpression':
+        node.expression = false;
+        return node;
+
+      case 'ArrowFunctionExpression':
+        node.expression = node.body.type !== 'BlockStatement';
+        return node;
+    }
+
+    return node;
+  }
+
+  mapChainExpression(nodeUnprocessed) {
+    /*
+    NOTE - In the below comments `MemberExpression` and `CallExpression`
+           are completely interchangable. For terseness we just reference
+           one each time.
+    */
+
+    /*
+    Hermes uses the old babel-style AST:
+    ```
+    (one?.two).three?.four;
+    ^^^^^^^^^^^^^^^^^^^^^^ OptionalMemberExpression
+    ^^^^^^^^^^^^^^^^ MemberExpression
+     ^^^^^^^^ OptionalMemberExpression
+    ```
+     We need to convert it to the ESTree representation:
+    ```
+    (one?.two).three?.four;
+    ^^^^^^^^^^^^^^^^^^^^^^ ChainExpression
+    ^^^^^^^^^^^^^^^^^^^^^^ MemberExpression[optional = true]
+    ^^^^^^^^^^^^^^^^ MemberExpression[optional = false]
+     ^^^^^^^^ ChainExpression
+     ^^^^^^^^ MemberExpression[optional = true]
+    ```
+     We do this by converting the AST and its children (depth first), and then unwrapping
+    the resulting AST as appropriate.
+     Put another way:
+    1) traverse to the leaf
+    2) if the current node is an `OptionalMemberExpression`:
+      a) if the `.object` is a `ChainExpression`:
+        i)   unwrap the child (`node.object = child.expression`)
+      b) convert this node to a `MemberExpression[optional = true]`
+      c) wrap this node (`node = ChainExpression[expression = node]`)
+    3) if the current node is a `MembedExpression`:
+      a) convert this node to a `MemberExpression[optional = true]`
+    */
+    const node = this.mapNodeDefault(nodeUnprocessed);
+
+    const {
+      child,
+      childKey,
+      isOptional
+    } = (() => {
+      const isOptional = node.optional === true;
+
+      if (node.type.endsWith('MemberExpression')) {
+        return {
+          child: node.object,
+          childKey: 'object',
+          isOptional
+        };
+      } else if (node.type.endsWith('CallExpression')) {
+        return {
+          child: node.callee,
+          childKey: 'callee',
+          isOptional
+        };
+      } else {
+        return {
+          child: node.expression,
+          childKey: 'expression',
+          isOptional: false
+        };
+      }
+    })();
+
+    const isChildUnwrappable = child.type === 'ChainExpression' && // (x?.y).z is semantically different to `x?.y.z`.
+    // In the un-parenthesised case `.z` is only executed if and only if `x?.y` returns a non-nullish value.
+    // In the parenthesised case, `.z` is **always** executed, regardless of the return of `x?.y`.
+    // As such the AST is different between the two cases.
+    //
+    // In the hermes AST - any member part of a non-short-circuited optional chain is represented with `OptionalMemberExpression`
+    // so if we see a `MemberExpression`, then we know we've hit a parenthesis boundary.
+    node.type !== 'MemberExpression' && node.type !== 'CallExpression';
+
+    if (node.type.startsWith('Optional')) {
+      node.type = node.type.replace('Optional', '');
+      node.optional = isOptional;
+    } else {
+      node.optional = false;
+    }
+
+    if (!isChildUnwrappable && !isOptional) {
+      return node;
+    }
+
+    if (isChildUnwrappable) {
+      const newChild = child.expression;
+      node[childKey] = newChild;
+    }
+
+    return {
+      type: 'ChainExpression',
+      expression: node,
+      loc: node.loc,
+      range: node.range
+    };
+  }
+
+  mapClassProperty(nodeUnprocessed) {
+    const node = this.mapNodeDefault(nodeUnprocessed);
+
+    const key = (() => {
+      if (node.type === 'ClassPrivateProperty') {
+        const key = this.mapNodeDefault(node.key);
+        return {
+          type: 'PrivateIdentifier',
+          name: key.name,
+          range: key.range,
+          loc: key.loc
+        };
+      }
+
+      return node.key;
+    })();
+
+    return { ...node,
+      computed: node.type === 'ClassPrivateProperty' ? false : node.computed,
+      key,
+      type: 'PropertyDefinition'
+    };
+  }
+
+  mapPrivateName(node) {
+    return {
+      type: 'PrivateIdentifier',
+      name: node.id.name,
+      // estree the location refers to the entire string including the hash token
+      range: node.range,
+      loc: node.loc
+    };
+  }
+
+  mapExportNamedDeclaration(nodeUnprocessed) {
+    const node = super.mapExportNamedDeclaration(nodeUnprocessed);
+    const namespaceSpecifier = node.specifiers.find(spec => spec.type === 'ExportNamespaceSpecifier');
+
+    if (namespaceSpecifier != null) {
+      var _node$exportKind;
+
+      if (node.specifiers.length !== 1) {
+        // this should already a hermes parser error - but let's be absolutely sure we're aligned with the spec
+        throw new Error('Cannot use an export all with any other specifiers');
+      }
+
+      return {
+        type: 'ExportAllDeclaration',
+        source: node.source,
+        exportKind: (_node$exportKind = node.exportKind) != null ? _node$exportKind : 'value',
+        exported: namespaceSpecifier.exported,
+        range: node.range,
+        loc: node.loc
+      };
+    }
+
+    return node;
+  }
+
+  mapExportAllDeclaration(nodeUnprocessed) {
+    var _node$exported;
+
+    const node = super.mapExportAllDeclaration(nodeUnprocessed);
+    node.exported = (_node$exported = node.exported) != null ? _node$exported : null;
+    return node;
+  }
+
 }
 
 exports.default = HermesToESTreeAdapter;