hermes-parser 0.12.1 → 0.13.0

package/dist/HermesToBabelAdapter.js

@@ -18,6 +18,13 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
  * 
  * @format
  */
+function createDefaultPosition() {
+  return {
+    line: 1,
+    column: 0
+  };
+}
+
 function createSyntaxError(node, err) {
   const syntaxError = new SyntaxError(err); // $FlowExpectedError[prop-missing]
 
@@ -118,8 +125,8 @@ class HermesToBabelAdapter extends _HermesASTAdapter.default {
       case 'IndexedAccessType':
       case 'OptionalIndexedAccessType':
       case 'KeyofTypeAnnotation':
-      case 'ConditionalType':
-      case 'InferType':
+      case 'ConditionalTypeAnnotation':
+      case 'InferTypeAnnotation':
       case 'TupleTypeLabeledElement':
       case 'TupleTypeSpreadElement':
       case 'ObjectTypeMappedTypeProperty':
@@ -606,21 +613,25 @@ class HermesToBabelAdapter extends _HermesASTAdapter.default {
       });
 
       rendersType = {
-        type: 'GenericTypeAnnotation',
-        id: {
-          type: 'QualifiedTypeIdentifier',
-          qualification: {
-            type: 'Identifier',
-            name: 'React',
-            ...createRendersTypeLoc()
-          },
+        type: 'TypeAnnotation',
+        typeAnnotation: {
+          type: 'GenericTypeAnnotation',
           id: {
-            type: 'Identifier',
-            name: 'Node',
-            ...createRendersTypeLoc()
-          }
+            type: 'QualifiedTypeIdentifier',
+            qualification: {
+              type: 'Identifier',
+              name: 'React',
+              ...createRendersTypeLoc()
+            },
+            id: {
+              type: 'Identifier',
+              name: 'Node',
+              ...createRendersTypeLoc()
+            }
+          },
+          typeParameters: null,
+          ...createRendersTypeLoc()
         },
-        typeParameters: null,
         ...createRendersTypeLoc()
       };
     }
@@ -638,88 +649,20 @@ class HermesToBabelAdapter extends _HermesASTAdapter.default {
       }
     }
 
-    const properties = nodeUnprocessed.params.map(param => {
-      switch (param.type) {
-        case 'RestElement':
-          {
-            delete param.typeAnnotation;
-            return param;
-          }
-
-        case 'ComponentParameter':
-          {
-            if (getParamName(param.name) === 'ref') {
-              throw createSyntaxError(param, 'Component parameters named "ref" are currently not supported');
-            }
-
-            if (param.name.type === 'Identifier') {
-              delete param.name.typeAnnotation;
-            }
-
-            if (param.local.type === 'AssignmentPattern') {
-              delete param.local.left.typeAnnotation;
-              delete param.local.left.optional;
-            } else {
-              delete param.local.typeAnnotation;
-              delete param.local.optional;
-            }
-
-            return {
-              type: 'ObjectProperty',
-              key: param.name,
-              value: param.local,
-              method: false,
-              shorthand: param.shorthand,
-              computed: false,
-              loc: param.loc,
-              start: param.start,
-              end: param.end
-            };
-          }
-
-        default:
-          {
-            throw createSyntaxError(param, `Unknown Component parameter type of "${param.type}"`);
-          }
-      }
-    });
-
-    const paramsLoc = (() => {
-      if (properties.length === 0) {
-        // No props, approximate range via existing nodes.
-        const startLoc = nodeUnprocessed.typeParameters != null ? nodeUnprocessed.typeParameters.loc : nodeUnprocessed.id.loc;
-        return {
-          start: startLoc.end,
-          end: rendersType.loc.start,
-          startRange: startLoc.endRange,
-          endRange: rendersType.loc.startRange
-        };
-      }
+    function createPropsTypeAnnotation(loc) {
+      // Create empty loc for type annotation nodes
+      const createParamsTypeLoc = () => ({
+        loc: {
+          start: loc.start != null ? { ...loc.start
+          } : createDefaultPosition(),
+          end: loc.end != null ? { ...loc.end
+          } : createDefaultPosition(),
+          rangeStart: loc.rangeStart,
+          rangeEnd: loc.rangeEnd
+        }
+      });
 
       return {
-        start: properties[0].loc.start,
-        end: properties[properties.length - 1].loc.end,
-        startRange: properties[0].loc.startRange,
-        endRange: properties[properties.length - 1].loc.endRange
-      };
-    })(); // Create empty loc for type annotation nodes
-
-
-    const createParamsTypeLoc = () => ({
-      loc: {
-        start: { ...paramsLoc.end
-        },
-        end: { ...paramsLoc.end
-        },
-        startRange: paramsLoc.endRange,
-        endRange: paramsLoc.endRange
-      }
-    });
-
-    const params = [{
-      type: 'ObjectPattern',
-      properties,
-      typeAnnotation: {
         type: 'TypeAnnotation',
         typeAnnotation: {
           type: 'GenericTypeAnnotation',
@@ -745,9 +688,84 @@ class HermesToBabelAdapter extends _HermesASTAdapter.default {
           ...createParamsTypeLoc()
         },
         ...createParamsTypeLoc()
-      },
-      loc: paramsLoc
-    }];
+      };
+    }
+
+    const params = (() => {
+      if (nodeUnprocessed.params.length === 0) {
+        return [];
+      } // Optimize `component Foo(...props: Props) {}` to `function Foo(props: Props) {}
+
+
+      if (nodeUnprocessed.params.length === 1 && nodeUnprocessed.params[0].type === 'RestElement') {
+        const restElement = nodeUnprocessed.params[0];
+        return [{ ...restElement.argument,
+          typeAnnotation: createPropsTypeAnnotation(restElement.argument.typeAnnotation.loc)
+        }];
+      }
+
+      const properties = nodeUnprocessed.params.map(param => {
+        switch (param.type) {
+          case 'RestElement':
+            {
+              delete param.typeAnnotation;
+              return param;
+            }
+
+          case 'ComponentParameter':
+            {
+              if (getParamName(param.name) === 'ref') {
+                throw createSyntaxError(param, 'Component parameters named "ref" are currently not supported');
+              }
+
+              if (param.name.type === 'Identifier') {
+                delete param.name.typeAnnotation;
+              }
+
+              if (param.local.type === 'AssignmentPattern') {
+                delete param.local.left.typeAnnotation;
+                delete param.local.left.optional;
+              } else {
+                delete param.local.typeAnnotation;
+                delete param.local.optional;
+              }
+
+              return {
+                type: 'ObjectProperty',
+                key: param.name,
+                value: param.local,
+                method: false,
+                shorthand: param.shorthand,
+                computed: false,
+                loc: param.loc,
+                start: param.start,
+                end: param.end
+              };
+            }
+
+          default:
+            {
+              throw createSyntaxError(param, `Unknown Component parameter type of "${param.type}"`);
+            }
+        }
+      });
+      const paramsLoc = {
+        start: properties[0].loc.start,
+        end: properties[properties.length - 1].loc.end,
+        rangeStart: properties[0].loc.rangeStart,
+        rangeEnd: properties[properties.length - 1].loc.rangeEnd
+      };
+      return [{
+        type: 'ObjectPattern',
+        properties,
+        typeAnnotation: createPropsTypeAnnotation({ ...paramsLoc,
+          start: paramsLoc.end,
+          rangeStart: paramsLoc.rangeEnd
+        }),
+        loc: paramsLoc
+      }];
+    })();
+
     const functionComponent = {
       type: 'FunctionDeclaration',
       id: nodeUnprocessed.id,

package/dist/HermesToBabelAdapter.js.flow

@@ -8,12 +8,23 @@
  * @format
  */
 
-import type {HermesNode} from './HermesAST';
+import type {
+  HermesNode,
+  HermesSourceLocation,
+  HermesPosition,
+} from './HermesAST';
 
 import HermesASTAdapter from './HermesASTAdapter';
 
 declare var BigInt: ?(value: $FlowFixMe) => mixed;
 
+function createDefaultPosition(): HermesPosition {
+  return {
+    line: 1,
+    column: 0,
+  };
+}
+
 function createSyntaxError(node: HermesNode, err: string): SyntaxError {
   const syntaxError = new SyntaxError(err);
   // $FlowExpectedError[prop-missing]
@@ -91,8 +102,8 @@ export default class HermesToBabelAdapter extends HermesASTAdapter {
       case 'IndexedAccessType':
       case 'OptionalIndexedAccessType':
       case 'KeyofTypeAnnotation':
-      case 'ConditionalType':
-      case 'InferType':
+      case 'ConditionalTypeAnnotation':
+      case 'InferTypeAnnotation':
       case 'TupleTypeLabeledElement':
       case 'TupleTypeSpreadElement':
       case 'ObjectTypeMappedTypeProperty':
@@ -588,21 +599,25 @@ export default class HermesToBabelAdapter extends HermesASTAdapter {
       });
 
       rendersType = {
-        type: 'GenericTypeAnnotation',
-        id: {
-          type: 'QualifiedTypeIdentifier',
-          qualification: {
-            type: 'Identifier',
-            name: 'React',
-            ...createRendersTypeLoc(),
-          },
+        type: 'TypeAnnotation',
+        typeAnnotation: {
+          type: 'GenericTypeAnnotation',
           id: {
-            type: 'Identifier',
-            name: 'Node',
-            ...createRendersTypeLoc(),
+            type: 'QualifiedTypeIdentifier',
+            qualification: {
+              type: 'Identifier',
+              name: 'React',
+              ...createRendersTypeLoc(),
+            },
+            id: {
+              type: 'Identifier',
+              name: 'Node',
+              ...createRendersTypeLoc(),
+            },
           },
+          typeParameters: null,
+          ...createRendersTypeLoc(),
         },
-        typeParameters: null,
         ...createRendersTypeLoc(),
       };
     }
@@ -621,121 +636,135 @@ export default class HermesToBabelAdapter extends HermesASTAdapter {
       }
     }
 
-    const properties = nodeUnprocessed.params.map(param => {
-      switch (param.type) {
-        case 'RestElement': {
-          delete param.typeAnnotation;
-          return param;
-        }
-        case 'ComponentParameter': {
-          if (getParamName(param.name) === 'ref') {
+    function createPropsTypeAnnotation(loc: HermesSourceLocation) {
+      // Create empty loc for type annotation nodes
+      const createParamsTypeLoc = () => ({
+        loc: {
+          start: loc.start != null ? {...loc.start} : createDefaultPosition(),
+          end: loc.end != null ? {...loc.end} : createDefaultPosition(),
+          rangeStart: loc.rangeStart,
+          rangeEnd: loc.rangeEnd,
+        },
+      });
+
+      return {
+        type: 'TypeAnnotation',
+        typeAnnotation: {
+          type: 'GenericTypeAnnotation',
+          id: {
+            type: 'Identifier',
+            name: '$ReadOnly',
+            ...createParamsTypeLoc(),
+          },
+          typeParameters: {
+            type: 'TypeParameterInstantiation',
+            params: [
+              {
+                type: 'ObjectTypeAnnotation',
+                callProperties: [],
+                properties: [],
+                indexers: [],
+                internalSlots: [],
+                exact: false,
+                inexact: true,
+                ...createParamsTypeLoc(),
+              },
+            ],
+            ...createParamsTypeLoc(),
+          },
+          ...createParamsTypeLoc(),
+        },
+        ...createParamsTypeLoc(),
+      };
+    }
+
+    const params = (() => {
+      if (nodeUnprocessed.params.length === 0) {
+        return [];
+      }
+
+      // Optimize `component Foo(...props: Props) {}` to `function Foo(props: Props) {}
+      if (
+        nodeUnprocessed.params.length === 1 &&
+        nodeUnprocessed.params[0].type === 'RestElement'
+      ) {
+        const restElement = nodeUnprocessed.params[0];
+        return [
+          {
+            ...restElement.argument,
+            typeAnnotation: createPropsTypeAnnotation(
+              restElement.argument.typeAnnotation.loc,
+            ),
+          },
+        ];
+      }
+
+      const properties = nodeUnprocessed.params.map(param => {
+        switch (param.type) {
+          case 'RestElement': {
+            delete param.typeAnnotation;
+            return param;
+          }
+          case 'ComponentParameter': {
+            if (getParamName(param.name) === 'ref') {
+              throw createSyntaxError(
+                param,
+                'Component parameters named "ref" are currently not supported',
+              );
+            }
+
+            if (param.name.type === 'Identifier') {
+              delete param.name.typeAnnotation;
+            }
+            if (param.local.type === 'AssignmentPattern') {
+              delete param.local.left.typeAnnotation;
+              delete param.local.left.optional;
+            } else {
+              delete param.local.typeAnnotation;
+              delete param.local.optional;
+            }
+
+            return {
+              type: 'ObjectProperty',
+              key: param.name,
+              value: param.local,
+              method: false,
+              shorthand: param.shorthand,
+              computed: false,
+              loc: param.loc,
+              start: param.start,
+              end: param.end,
+            };
+          }
+          default: {
             throw createSyntaxError(
               param,
-              'Component parameters named "ref" are currently not supported',
+              `Unknown Component parameter type of "${param.type}"`,
             );
           }
-
-          if (param.name.type === 'Identifier') {
-            delete param.name.typeAnnotation;
-          }
-          if (param.local.type === 'AssignmentPattern') {
-            delete param.local.left.typeAnnotation;
-            delete param.local.left.optional;
-          } else {
-            delete param.local.typeAnnotation;
-            delete param.local.optional;
-          }
-
-          return {
-            type: 'ObjectProperty',
-            key: param.name,
-            value: param.local,
-            method: false,
-            shorthand: param.shorthand,
-            computed: false,
-            loc: param.loc,
-            start: param.start,
-            end: param.end,
-          };
-        }
-        default: {
-          throw createSyntaxError(
-            param,
-            `Unknown Component parameter type of "${param.type}"`,
-          );
         }
-      }
-    });
-
-    const paramsLoc = (() => {
-      if (properties.length === 0) {
-        // No props, approximate range via existing nodes.
-        const startLoc =
-          nodeUnprocessed.typeParameters != null
-            ? nodeUnprocessed.typeParameters.loc
-            : nodeUnprocessed.id.loc;
-        return {
-          start: startLoc.end,
-          end: rendersType.loc.start,
-          startRange: startLoc.endRange,
-          endRange: rendersType.loc.startRange,
-        };
-      }
+      });
 
-      return {
+      const paramsLoc = {
         start: properties[0].loc.start,
         end: properties[properties.length - 1].loc.end,
-        startRange: properties[0].loc.startRange,
-        endRange: properties[properties.length - 1].loc.endRange,
+        rangeStart: properties[0].loc.rangeStart,
+        rangeEnd: properties[properties.length - 1].loc.rangeEnd,
       };
-    })();
-
-    // Create empty loc for type annotation nodes
-    const createParamsTypeLoc = () => ({
-      loc: {
-        start: {...paramsLoc.end},
-        end: {...paramsLoc.end},
-        startRange: paramsLoc.endRange,
-        endRange: paramsLoc.endRange,
-      },
-    });
 
-    const params = [
-      {
-        type: 'ObjectPattern',
-        properties,
-        typeAnnotation: {
-          type: 'TypeAnnotation',
-          typeAnnotation: {
-            type: 'GenericTypeAnnotation',
-            id: {
-              type: 'Identifier',
-              name: '$ReadOnly',
-              ...createParamsTypeLoc(),
-            },
-            typeParameters: {
-              type: 'TypeParameterInstantiation',
-              params: [
-                {
-                  type: 'ObjectTypeAnnotation',
-                  callProperties: [],
-                  properties: [],
-                  indexers: [],
-                  internalSlots: [],
-                  exact: false,
-                  inexact: true,
-                  ...createParamsTypeLoc(),
-                },
-              ],
-              ...createParamsTypeLoc(),
-            },
-            ...createParamsTypeLoc(),
-          },
-          ...createParamsTypeLoc(),
+      return [
+        {
+          type: 'ObjectPattern',
+          properties,
+          typeAnnotation: createPropsTypeAnnotation({
+            ...paramsLoc,
+            start: paramsLoc.end,
+            rangeStart: paramsLoc.rangeEnd,
+          }),
+          loc: paramsLoc,
         },
-        loc: paramsLoc,
-      },
-    ];
+      ];
+    })();
 
     const functionComponent = {
       type: 'FunctionDeclaration',

package/dist/ParserOptions.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ParserOptionsKeys = void 0;
+
+/**
+ * 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.
+ *
+ * 
+ * @format
+ */
+const ParserOptionsKeys = new Set(['allowReturnOutsideFunction', 'babel', 'flow', 'enableExperimentalComponentSyntax', 'sourceFilename', 'sourceType', 'tokens']);
+exports.ParserOptionsKeys = ParserOptionsKeys;

package/dist/ParserOptions.js.flow

@@ -17,3 +17,13 @@ export type ParserOptions = {
   sourceType?: 'module' | 'script' | 'unambiguous',
   tokens?: boolean,
 };
+
+export const ParserOptionsKeys: $ReadOnlySet<$Keys<ParserOptions>> = new Set([
+  'allowReturnOutsideFunction',
+  'babel',
+  'flow',
+  'enableExperimentalComponentSyntax',
+  'sourceFilename',
+  'sourceType',
+  'tokens',
+]);

package/dist/generated/ESTreeVisitorKeys.js

@@ -147,7 +147,7 @@ module.exports = {
   PrivateIdentifier: [],
   Program: ['body'],
   Property: ['key', 'value'],
-  PropertyDefinition: ['key', 'value', 'variance', 'typeAnnotation', 'tsModifiers'],
+  PropertyDefinition: ['key', 'value', 'variance', 'typeAnnotation'],
   QualifiedTypeIdentifier: ['qualification', 'id'],
   QualifiedTypeofIdentifier: ['qualification', 'id'],
   RestElement: ['argument'],

package/dist/generated/ParserVisitorKeys.js

@@ -513,8 +513,7 @@ const HERMES_AST_VISITOR_KEYS = {
     key: 'Node',
     value: 'Node',
     variance: 'Node',
-    typeAnnotation: 'Node',
-    tsModifiers: 'Node'
+    typeAnnotation: 'Node'
   },
   QualifiedTypeIdentifier: {
     qualification: 'Node',

package/dist/index.js

@@ -32,6 +32,15 @@ var _ESTreeVisitorKeys = _interopRequireDefault(require("./generated/ESTreeVisit
 
 exports.FlowVisitorKeys = _ESTreeVisitorKeys.default;
 
+var _ParserOptions = require("./ParserOptions");
+
+Object.keys(_ParserOptions).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _ParserOptions[key]) return;
+  exports[key] = _ParserOptions[key];
+});
+
 var _SimpleTraverser = require("./traverse/SimpleTraverser");
 
 Object.keys(_SimpleTraverser).forEach(function (key) {

package/dist/index.js.flow

@@ -84,6 +84,7 @@ export function parse(
 }
 
 export type {ParserOptions} from './ParserOptions';
+export * from './ParserOptions';
 export * from './traverse/SimpleTraverser';
 export * from './transform/SimpleTransform';
 export * from './traverse/getVisitorKeys';

package/dist/transform/astNodeMutationHelpers.js

@@ -103,8 +103,7 @@ function removeNodeOnParent(originalNode, originalNodeParent) {
 
 function setParentPointersInDirectChildren(node) {
   for (const key of (0, _getVisitorKeys.getVisitorKeys)(node)) {
-    if ((0, _getVisitorKeys.isNode)( // $FlowExpectedError[prop-missing]
-    node[key])) {
+    if ((0, _getVisitorKeys.isNode)(node[key])) {
       node[key].parent = node;
     } else if (Array.isArray(node[key])) {
       for (const child of node[key]) {
@@ -138,7 +137,8 @@ function updateAllParentPointers(node) {
 
 function nodeWith(node, overrideProps) {
   // Check if this will actually result in a change, maintaining referential equality is important.
-  const willBeUnchanged = Object.entries(overrideProps).every(([key, value]) => // $FlowExpectedError[prop-missing]
+  const willBeUnchanged = Object.entries(overrideProps).every(([key, value]) => // $FlowExpectedError[incompatible-call]
+  // $FlowExpectedError[prop-missing]
   Array.isArray(value) ? (0, _astArrayMutationHelpers.arrayIsEqual)(node[key], value) : node[key] === value);
 
   if (willBeUnchanged) {

package/dist/transform/astNodeMutationHelpers.js.flow

@@ -115,13 +115,8 @@ export function removeNodeOnParent(
  * Corrects the parent pointers in direct children of the given node.
  */
 export function setParentPointersInDirectChildren(node: ESNode): void {
-  for (const key of getVisitorKeys(node)) {
-    if (
-      isNode(
-        // $FlowExpectedError[prop-missing]
-        node[key],
-      )
-    ) {
+  for (const key: $FlowFixMe of getVisitorKeys(node)) {
+    if (isNode(node[key])) {
       node[key].parent = node;
     } else if (Array.isArray(node[key])) {
       for (const child of node[key]) {
@@ -152,6 +147,7 @@ export function updateAllParentPointers(node: ESNode) {
 export function nodeWith<T: ESNode>(node: T, overrideProps: Partial<T>): T {
   // Check if this will actually result in a change, maintaining referential equality is important.
   const willBeUnchanged = Object.entries(overrideProps).every(([key, value]) =>
+    // $FlowExpectedError[incompatible-call]
     // $FlowExpectedError[prop-missing]
     Array.isArray(value) ? arrayIsEqual(node[key], value) : node[key] === value,
   );