hermes-parser 0.5.0 → 0.8.0

package/dist/HermesToESTreeAdapter.js.flow

@@ -1,5 +1,5 @@
 /**
- * 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.
@@ -21,6 +21,9 @@ import type {HermesNode} from './HermesAST';
 import type {ParserOptions} from './ParserOptions';
 
 import HermesASTAdapter from './HermesASTAdapter';
+import {getModuleDocblock} from './getModuleDocblock';
+
+declare var BigInt: ?(value: $FlowFixMe) => mixed;
 
 export default class HermesToESTreeAdapter extends HermesASTAdapter {
   +code: string;
@@ -43,6 +46,9 @@ export default class HermesToESTreeAdapter extends HermesASTAdapter {
     };
 
     node.range = [loc.rangeStart, loc.rangeEnd];
+
+    delete node.start;
+    delete node.end;
   }
 
   mapNode(node: HermesNode): HermesNode {
@@ -55,13 +61,18 @@ export default class HermesToESTreeAdapter extends HermesASTAdapter {
       case 'BooleanLiteral':
       case 'StringLiteral':
       case 'NumericLiteral':
+      case 'JSXStringLiteral':
         return this.mapSimpleLiteral(node);
+      case 'BigIntLiteral':
+        return this.mapBigIntLiteral(node);
       case 'RegExpLiteral':
         return this.mapRegExpLiteral(node);
       case 'Empty':
         return this.mapEmpty(node);
       case 'TemplateElement':
         return this.mapTemplateElement(node);
+      case 'BigIntLiteralTypeAnnotation':
+        return this.mapBigIntLiteralTypeAnnotation(node);
       case 'GenericTypeAnnotation':
         return this.mapGenericTypeAnnotation(node);
       case 'ImportDeclaration':
@@ -74,9 +85,22 @@ export default class HermesToESTreeAdapter extends HermesASTAdapter {
         return this.mapExportNamedDeclaration(node);
       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 'MemberExpression':
+      case 'OptionalMemberExpression':
+      case 'CallExpression':
+      case 'OptionalCallExpression':
+        return this.mapChainExpression(node);
       default:
         return this.mapNodeDefault(node);
     }
@@ -86,22 +110,65 @@ export default class HermesToESTreeAdapter extends HermesASTAdapter {
     node = this.mapNodeDefault(node);
     node.sourceType = this.getSourceType();
 
+    node.docblock = getModuleDocblock(node);
+
     return node;
   }
 
   mapSimpleLiteral(node: HermesNode): HermesNode {
-    node.type = 'Literal';
-    node.raw = this.code.slice(node.range[0], node.range[1]);
+    return {
+      type: 'Literal',
+      loc: node.loc,
+      range: node.range,
+      value: node.value,
+      raw: this.code.slice(node.range[0], node.range[1]),
+      literalType: (() => {
+        switch (node.type) {
+          case 'NullLiteral':
+            return 'null';
 
-    return node;
+          case 'BooleanLiteral':
+            return 'boolean';
+
+          case 'StringLiteral':
+          case 'JSXStringLiteral':
+            return 'string';
+
+          case 'NumericLiteral':
+            return 'numeric';
+
+          case 'BigIntLiteral':
+            return 'bigint';
+
+          case 'RegExpLiteral':
+            return 'regexp';
+        }
+        return null;
+      })(),
+    };
   }
 
-  mapNullLiteral(node: HermesNode): HermesNode {
-    node.type = 'Literal';
-    node.value = null;
-    node.raw = this.code.slice(node.range[0], node.range[1]);
+  mapBigIntLiteral(node: HermesNode): HermesNode {
+    const newNode = this.mapSimpleLiteral(node);
+    const bigint = node.bigint
+      // estree spec is to not have a trailing `n` on this property
+      // https://github.com/estree/estree/blob/db962bb417a97effcfe9892f87fbb93c81a68584/es2020.md#bigintliteral
+      .replace(/n$/, '')
+      // `BigInt` doesn't accept numeric separator and `bigint` property should not include numeric separator
+      .replace(/_/, '');
+    return {
+      ...newNode,
+      // coerce the string to a bigint value if supported by the environment
+      value: typeof BigInt === 'function' ? BigInt(bigint) : null,
+      bigint,
+    };
+  }
 
-    return node;
+  mapNullLiteral(node: HermesNode): HermesNode {
+    return {
+      ...this.mapSimpleLiteral(node),
+      value: null,
+    };
   }
 
   mapRegExpLiteral(node: HermesNode): HermesNode {
@@ -116,11 +183,8 @@ export default class HermesToESTreeAdapter extends HermesASTAdapter {
     }
 
     return {
-      type: 'Literal',
-      loc: node.loc,
-      range: node.range,
+      ...this.mapSimpleLiteral(node),
       value,
-      raw: this.code.slice(node.range[0], node.range[1]),
       regex: {
         pattern,
         flags,
@@ -128,6 +192,11 @@ export default class HermesToESTreeAdapter extends HermesASTAdapter {
     };
   }
 
+  mapBigIntLiteralTypeAnnotation(node: HermesNode): HermesNode {
+    node.value = null;
+    return node;
+  }
+
   mapTemplateElement(node: HermesNode): HermesNode {
     return {
       type: 'TemplateElement',
@@ -144,7 +213,7 @@ export default class HermesToESTreeAdapter extends HermesASTAdapter {
   mapGenericTypeAnnotation(node: HermesNode): HermesNode {
     // Convert simple `this` generic type to ThisTypeAnnotation
     if (
-      node.typeParameters === null &&
+      node.typeParameters == null &&
       node.id.type === 'Identifier' &&
       node.id.name === 'this'
     ) {
@@ -158,6 +227,17 @@ export default class HermesToESTreeAdapter extends HermesASTAdapter {
     return this.mapNodeDefault(node);
   }
 
+  mapProperty(nodeUnprocessed: HermesNode): HermesNode {
+    const node = this.mapNodeDefault(nodeUnprocessed);
+
+    if (node.value.type === 'FunctionExpression') {
+      node.value.loc.start = node.key.loc.end;
+      node.value.range[0] = node.key.range[1];
+    }
+
+    return node;
+  }
+
   mapComment(node: HermesNode): HermesNode {
     if (node.type === 'CommentBlock') {
       node.type = 'Block';
@@ -167,4 +247,191 @@ export default class HermesToESTreeAdapter extends HermesASTAdapter {
 
     return node;
   }
+
+  mapFunction(nodeUnprocessed: HermesNode): HermesNode {
+    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: HermesNode): HermesNode {
+    /*
+    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} = ((): {
+      child: HermesNode,
+      childKey: string,
+      isOptional: boolean,
+    } => {
+      const isOptional: boolean = 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: HermesNode): HermesNode {
+    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: HermesNode): HermesNode {
+    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: HermesNode): HermesNode {
+    const node = super.mapExportNamedDeclaration(nodeUnprocessed);
+
+    const namespaceSpecifier = node.specifiers.find(
+      spec => spec.type === 'ExportNamespaceSpecifier',
+    );
+    if (namespaceSpecifier != null) {
+      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 ?? 'value',
+        exported: namespaceSpecifier.exported,
+        range: node.range,
+        loc: node.loc,
+      };
+    }
+
+    return node;
+  }
+
+  mapExportAllDeclaration(nodeUnprocessed: HermesNode): HermesNode {
+    const node = super.mapExportAllDeclaration(nodeUnprocessed);
+    node.exported = node.exported ?? null;
+    return node;
+  }
 }

package/dist/ParserOptions.js.flow

@@ -1,5 +1,5 @@
 /**
- * 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.

package/dist/generated/visitor-keys.js

@@ -1,5 +1,5 @@
 /**
- * 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.
@@ -7,17 +7,22 @@
  * 
  * @format
  */
+// lint directives to let us do some basic validation of generated files
+
+/* eslint no-undef: 'error', no-unused-vars: ['error', {vars: "local"}], no-redeclare: 'error' */
+
+/* global $NonMaybeType, $Partial, $ReadOnly, $ReadOnlyArray */
 'use strict';
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.NODE_LIST_CHILD = exports.NODE_CHILD = exports.HERMES_AST_VISITOR_KEYS = void 0;
-var NODE_CHILD = 'Node';
+const NODE_CHILD = 'Node';
 exports.NODE_CHILD = NODE_CHILD;
-var NODE_LIST_CHILD = 'NodeList';
+const NODE_LIST_CHILD = 'NodeList';
 exports.NODE_LIST_CHILD = NODE_LIST_CHILD;
-var HERMES_AST_VISITOR_KEYS = {
+const HERMES_AST_VISITOR_KEYS = {
   AnyTypeAnnotation: {},
   ArrayExpression: {
     elements: 'NodeList'
@@ -48,6 +53,8 @@ var HERMES_AST_VISITOR_KEYS = {
   AwaitExpression: {
     argument: 'Node'
   },
+  BigIntLiteral: {},
+  BigIntLiteralTypeAnnotation: {},
   BinaryExpression: {
     left: 'Node',
     right: 'Node'
@@ -70,6 +77,9 @@ var HERMES_AST_VISITOR_KEYS = {
     param: 'Node',
     body: 'Node'
   },
+  ChainExpression: {
+    expression: 'Node'
+  },
   ClassBody: {
     body: 'NodeList'
   },
@@ -78,7 +88,7 @@ var HERMES_AST_VISITOR_KEYS = {
     typeParameters: 'Node',
     superClass: 'Node',
     superTypeParameters: 'Node',
-    "implements": 'NodeList',
+    implements: 'NodeList',
     decorators: 'NodeList',
     body: 'Node'
   },
@@ -87,7 +97,7 @@ var HERMES_AST_VISITOR_KEYS = {
     typeParameters: 'Node',
     superClass: 'Node',
     superTypeParameters: 'Node',
-    "implements": 'NodeList',
+    implements: 'NodeList',
     decorators: 'NodeList',
     body: 'Node'
   },
@@ -95,18 +105,6 @@ var HERMES_AST_VISITOR_KEYS = {
     id: 'Node',
     typeParameters: 'Node'
   },
-  ClassPrivateProperty: {
-    key: 'Node',
-    value: 'Node',
-    variance: 'Node',
-    typeAnnotation: 'Node'
-  },
-  ClassProperty: {
-    key: 'Node',
-    value: 'Node',
-    variance: 'Node',
-    typeAnnotation: 'Node'
-  },
   ConditionalExpression: {
     test: 'Node',
     alternate: 'Node',
@@ -119,8 +117,8 @@ var HERMES_AST_VISITOR_KEYS = {
   DeclareClass: {
     id: 'Node',
     typeParameters: 'Node',
-    "extends": 'NodeList',
-    "implements": 'NodeList',
+    extends: 'NodeList',
+    implements: 'NodeList',
     mixins: 'NodeList',
     body: 'Node'
   },
@@ -142,7 +140,7 @@ var HERMES_AST_VISITOR_KEYS = {
   DeclareInterface: {
     id: 'Node',
     typeParameters: 'Node',
-    "extends": 'NodeList',
+    extends: 'NodeList',
     body: 'Node'
   },
   DeclareModule: {
@@ -205,6 +203,7 @@ var HERMES_AST_VISITOR_KEYS = {
   },
   ExistsTypeAnnotation: {},
   ExportAllDeclaration: {
+    exported: 'Node',
     source: 'Node'
   },
   ExportDefaultDeclaration: {
@@ -215,9 +214,6 @@ var HERMES_AST_VISITOR_KEYS = {
     specifiers: 'NodeList',
     source: 'Node'
   },
-  ExportNamespaceSpecifier: {
-    exported: 'Node'
-  },
   ExportSpecifier: {
     exported: 'Node',
     local: 'Node'
@@ -259,7 +255,7 @@ var HERMES_AST_VISITOR_KEYS = {
   },
   FunctionTypeAnnotation: {
     params: 'NodeList',
-    "this": 'Node',
+    this: 'Node',
     returnType: 'Node',
     rest: 'Node',
     typeParameters: 'Node'
@@ -311,7 +307,7 @@ var HERMES_AST_VISITOR_KEYS = {
   InterfaceDeclaration: {
     id: 'Node',
     typeParameters: 'Node',
-    "extends": 'NodeList',
+    extends: 'NodeList',
     body: 'Node'
   },
   InterfaceExtends: {
@@ -319,7 +315,7 @@ var HERMES_AST_VISITOR_KEYS = {
     typeParameters: 'Node'
   },
   InterfaceTypeAnnotation: {
-    "extends": 'NodeList',
+    extends: 'NodeList',
     body: 'Node'
   },
   IntersectionTypeAnnotation: {
@@ -442,22 +438,11 @@ var HERMES_AST_VISITOR_KEYS = {
     impltype: 'Node',
     supertype: 'Node'
   },
-  OptionalCallExpression: {
-    callee: 'Node',
-    typeArguments: 'Node',
-    arguments: 'NodeList'
-  },
   OptionalIndexedAccessType: {
     objectType: 'Node',
     indexType: 'Node'
   },
-  OptionalMemberExpression: {
-    object: 'Node',
-    property: 'Node'
-  },
-  PrivateName: {
-    id: 'Node'
-  },
+  PrivateIdentifier: {},
   Program: {
     body: 'NodeList'
   },
@@ -465,6 +450,12 @@ var HERMES_AST_VISITOR_KEYS = {
     key: 'Node',
     value: 'Node'
   },
+  PropertyDefinition: {
+    key: 'Node',
+    value: 'Node',
+    variance: 'Node',
+    typeAnnotation: 'Node'
+  },
   QualifiedTypeIdentifier: {
     qualification: 'Node',
     id: 'Node'
@@ -535,7 +526,7 @@ var HERMES_AST_VISITOR_KEYS = {
   TypeParameter: {
     bound: 'Node',
     variance: 'Node',
-    "default": 'Node'
+    default: 'Node'
   },
   TypeParameterDeclaration: {
     params: 'NodeList'
@@ -593,6 +584,30 @@ var HERMES_AST_VISITOR_KEYS = {
     returnType: 'Node',
     typeParameters: 'NodeList'
   },
-  Import: {}
+  Import: {},
+  ClassProperty: {
+    key: 'Node',
+    value: 'Node',
+    variance: 'Node',
+    typeAnnotation: 'Node'
+  },
+  ClassPrivateProperty: {
+    key: 'Node',
+    value: 'Node',
+    variance: 'Node',
+    typeAnnotation: 'Node'
+  },
+  PrivateName: {
+    id: 'Node'
+  },
+  OptionalCallExpression: {
+    callee: 'Node',
+    typeArguments: 'Node',
+    arguments: 'NodeList'
+  },
+  OptionalMemberExpression: {
+    object: 'Node',
+    property: 'Node'
+  }
 };
 exports.HERMES_AST_VISITOR_KEYS = HERMES_AST_VISITOR_KEYS;

package/dist/generated/visitor-keys.js.flow

@@ -1,5 +1,5 @@
 /**
- * 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.