hermes-parser 0.17.0 → 0.18.0

package/dist/estree/StripComponentSyntax.js

@@ -129,7 +129,7 @@ function mapComponentParameters(params) {
   } // Optimize `component Foo(...props: Props) {}` to `function Foo(props: Props) {}
 
 
-  if (params.length === 1 && params[0].type === 'RestElement' && (params[0].argument.type === 'Identifier' || params[0].argument.type === 'ObjectPattern')) {
+  if (params.length === 1 && params[0].type === 'RestElement' && params[0].argument.type === 'Identifier') {
     var _restElementArgument$, _restElementArgument$2;
 
     const restElementArgument = params[0].argument;
@@ -151,7 +151,7 @@ function mapComponentParameters(params) {
 
     return true;
   });
-  const propsProperties = paramsWithoutRef.map(mapComponentParameter);
+  const propsProperties = paramsWithoutRef.flatMap(mapComponentParameter);
   let props = null;
 
   if (propsProperties.length === 0) {
@@ -195,16 +195,7 @@ function mapComponentParameters(params) {
   let ref = null;
 
   if (refParam != null) {
-    const refType = refParam.local;
-    ref = {
-      type: 'Identifier',
-      name: 'ref',
-      optional: false,
-      typeAnnotation: refType.type === 'AssignmentPattern' ? refType.left.typeAnnotation : refType.typeAnnotation,
-      loc: refParam.loc,
-      range: refParam.range,
-      parent: EMPTY_PARENT
-    };
+    ref = refParam.local;
   }
 
   return {
@@ -217,21 +208,36 @@ function mapComponentParameter(param) {
   switch (param.type) {
     case 'RestElement':
       {
-        const a = nodeWith(param, {
-          typeAnnotation: null,
-          argument: nodeWith(param.argument, {
-            typeAnnotation: null
-          })
-        });
-        return a;
+        switch (param.argument.type) {
+          case 'Identifier':
+            {
+              const a = nodeWith(param, {
+                typeAnnotation: null,
+                argument: nodeWith(param.argument, {
+                  typeAnnotation: null
+                })
+              });
+              return [a];
+            }
+
+          case 'ObjectPattern':
+            {
+              return param.argument.properties.map(property => {
+                return nodeWith(property, {
+                  typeAnnotation: null
+                });
+              });
+            }
+
+          default:
+            {
+              throw (0, _createSyntaxError.createSyntaxError)(param, `Unhandled ${param.argument.type} encountered in restParameter`);
+            }
+        }
       }
 
     case 'ComponentParameter':
       {
-        if (getComponentParameterName(param.name) === 'ref') {
-          throw (0, _createSyntaxError.createSyntaxError)(param, 'Component parameters named "ref" are currently not supported');
-        }
-
         let value;
 
         if (param.local.type === 'AssignmentPattern') {
@@ -250,7 +256,7 @@ function mapComponentParameter(param) {
 
 
         if (param.name.type === 'Identifier' && param.shorthand && (value.type === 'Identifier' || value.type === 'AssignmentPattern')) {
-          return {
+          return [{
             type: 'Property',
             key: param.name,
             kind: 'init',
@@ -261,11 +267,11 @@ function mapComponentParameter(param) {
             loc: param.loc,
             range: param.range,
             parent: EMPTY_PARENT
-          };
+          }];
         } // Complex params
 
 
-        return {
+        return [{
           type: 'Property',
           key: param.name,
           kind: 'init',
@@ -276,7 +282,7 @@ function mapComponentParameter(param) {
           loc: param.loc,
           range: param.range,
           parent: EMPTY_PARENT
-        };
+        }];
       }
 
     default:

package/dist/estree/StripComponentSyntax.js.flow

@@ -38,6 +38,8 @@ import type {
   VariableDeclaration,
   ModuleDeclaration,
   Statement,
+  AssignmentPattern,
+  BindingName,
 } from 'hermes-estree';
 
 import {SimpleTransform} from '../transform/SimpleTransform';
@@ -148,7 +150,7 @@ function mapComponentParameters(
   params: $ReadOnlyArray<ComponentParameter | RestElement>,
 ): $ReadOnly<{
   props: ?(ObjectPattern | Identifier),
-  ref: ?Identifier,
+  ref: ?(BindingName | AssignmentPattern),
 }> {
   if (params.length === 0) {
     return {props: null, ref: null};
@@ -158,8 +160,7 @@ function mapComponentParameters(
   if (
     params.length === 1 &&
     params[0].type === 'RestElement' &&
-    (params[0].argument.type === 'Identifier' ||
-      params[0].argument.type === 'ObjectPattern')
+    params[0].argument.type === 'Identifier'
   ) {
     const restElementArgument = params[0].argument;
     return {
@@ -187,7 +188,7 @@ function mapComponentParameters(
     return true;
   });
 
-  const propsProperties = paramsWithoutRef.map(mapComponentParameter);
+  const propsProperties = paramsWithoutRef.flatMap(mapComponentParameter);
 
   let props = null;
   if (propsProperties.length === 0) {
@@ -237,19 +238,7 @@ function mapComponentParameters(
 
   let ref = null;
   if (refParam != null) {
-    const refType = refParam.local;
-    ref = {
-      type: 'Identifier',
-      name: 'ref',
-      optional: false,
-      typeAnnotation:
-        refType.type === 'AssignmentPattern'
-          ? refType.left.typeAnnotation
-          : refType.typeAnnotation,
-      loc: refParam.loc,
-      range: refParam.range,
-      parent: EMPTY_PARENT,
-    };
+    ref = refParam.local;
   }
 
   return {
@@ -260,23 +249,33 @@ function mapComponentParameters(
 
 function mapComponentParameter(
   param: ComponentParameter | RestElement,
-): DestructuringObjectProperty | RestElement {
+): Array<DestructuringObjectProperty | RestElement> {
   switch (param.type) {
     case 'RestElement': {
-      const a = nodeWith(param, {
-        typeAnnotation: null,
-        argument: nodeWith(param.argument, {typeAnnotation: null}),
-      });
-      return a;
+      switch (param.argument.type) {
+        case 'Identifier': {
+          const a = nodeWith(param, {
+            typeAnnotation: null,
+            argument: nodeWith(param.argument, {typeAnnotation: null}),
+          });
+          return [a];
+        }
+        case 'ObjectPattern': {
+          return param.argument.properties.map(property => {
+            return nodeWith(property, {
+              typeAnnotation: null,
+            });
+          });
+        }
+        default: {
+          throw createSyntaxError(
+            param,
+            `Unhandled ${param.argument.type} encountered in restParameter`,
+          );
+        }
+      }
     }
     case 'ComponentParameter': {
-      if (getComponentParameterName(param.name) === 'ref') {
-        throw createSyntaxError(
-          param,
-          'Component parameters named "ref" are currently not supported',
-        );
-      }
-
       let value;
       if (param.local.type === 'AssignmentPattern') {
         value = nodeWith(param.local, {
@@ -298,33 +297,37 @@ function mapComponentParameter(
         param.shorthand &&
         (value.type === 'Identifier' || value.type === 'AssignmentPattern')
       ) {
-        return {
+        return [
+          {
+            type: 'Property',
+            key: param.name,
+            kind: 'init',
+            value,
+            method: false,
+            shorthand: true,
+            computed: false,
+            loc: param.loc,
+            range: param.range,
+            parent: EMPTY_PARENT,
+          },
+        ];
+      }
+
+      // Complex params
+      return [
+        {
           type: 'Property',
           key: param.name,
           kind: 'init',
           value,
           method: false,
-          shorthand: true,
+          shorthand: false,
           computed: false,
           loc: param.loc,
           range: param.range,
           parent: EMPTY_PARENT,
-        };
-      }
-
-      // Complex params
-      return {
-        type: 'Property',
-        key: param.name,
-        kind: 'init',
-        value,
-        method: false,
-        shorthand: false,
-        computed: false,
-        loc: param.loc,
-        range: param.range,
-        parent: EMPTY_PARENT,
-      };
+        },
+      ];
     }
     default: {
       throw createSyntaxError(

package/dist/utils/mutateESTreeASTForPrettier.js

@@ -17,7 +17,17 @@ exports.default = mutate;
 var _SimpleTransform = require("../transform/SimpleTransform");
 
 // https://github.com/prettier/prettier/blob/d962466a828f8ef51435e3e8840178d90b7ec6cd/src/language-js/parse/postprocess/index.js#L161-L182
-function transformChainExpression(node) {
+function transformChainExpression(node, comments) {
+  if (comments != null) {
+    var _node$comments;
+
+    // $FlowExpectedError[prop-missing]
+    const joinedComments = comments.concat((_node$comments = node.comments) != null ? _node$comments : []); // $FlowExpectedError[prop-missing]
+    // $FlowFixMe[cannot-write]
+
+    node.comments = joinedComments;
+  }
+
   switch (node.type) {
     case 'CallExpression':
       // $FlowExpectedError[cannot-spread-interface]
@@ -56,7 +66,8 @@ function mutate(rootNode, visitorKeys) {
 
 
       if (node.type === 'ChainExpression') {
-        return transformChainExpression(node.expression);
+        // $FlowFixMe[prop-missing]
+        return transformChainExpression(node.expression, node == null ? void 0 : node.comments);
       } // Prettier currently relies on comparing the `node` vs `node.value` start positions to know if an
       // `ObjectTypeProperty` is a method or not (instead of using the `node.method` boolean). To correctly print
       // the node when its not a method we need the start position to be different from the `node.value`s start

package/dist/utils/mutateESTreeASTForPrettier.js.flow

@@ -10,12 +10,22 @@
 
 'use strict';
 
-import type {ESNode, Program} from 'hermes-estree';
+import type {ESNode, Program, Comment} from 'hermes-estree';
 import type {VisitorKeysType} from '../traverse/getVisitorKeys';
 import {SimpleTransform} from '../transform/SimpleTransform';
 
 // https://github.com/prettier/prettier/blob/d962466a828f8ef51435e3e8840178d90b7ec6cd/src/language-js/parse/postprocess/index.js#L161-L182
-function transformChainExpression(node: ESNode): ESNode {
+function transformChainExpression(
+  node: ESNode,
+  comments: ?$ReadOnlyArray<Comment>,
+): ESNode {
+  if (comments != null) {
+    // $FlowExpectedError[prop-missing]
+    const joinedComments = comments.concat(node.comments ?? []);
+    // $FlowExpectedError[prop-missing]
+    // $FlowFixMe[cannot-write]
+    node.comments = joinedComments;
+  }
   switch (node.type) {
     case 'CallExpression':
       // $FlowExpectedError[cannot-spread-interface]
@@ -59,7 +69,8 @@ export default function mutate(
       // so we have to apply their transform to our AST so it can actually format it.
       // Note: Only needed for prettier V2, this is supported in V3
       if (node.type === 'ChainExpression') {
-        return transformChainExpression(node.expression);
+        // $FlowFixMe[prop-missing]
+        return transformChainExpression(node.expression, node?.comments);
       }
 
       // Prettier currently relies on comparing the `node` vs `node.value` start positions to know if an

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hermes-parser",
-  "version": "0.17.0",
+  "version": "0.18.0",
   "description": "A JavaScript parser built from the Hermes engine",
   "main": "dist/index.js",
   "license": "MIT",
@@ -9,7 +9,7 @@
     "url": "git@github.com:facebook/hermes.git"
   },
   "dependencies": {
-    "hermes-estree": "0.17.0"
+    "hermes-estree": "0.18.0"
   },
   "devDependencies": {
     "@babel/parser": "7.7.4",