fix(MemberExpression to LogicalExpression): 🐛

Author: vivaxy

lib/__tests__/fixtures/parse/logical-expression-000/input.js

@@ -0,0 +1 @@
+item && item.src

lib/__tests__/fixtures/parse/logical-expression-000/output.json

@@ -0,0 +1,28 @@
+{
+  "type": "Program",
+  "body": [
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "LogicalExpression",
+        "operator": "&&",
+        "left": {
+          "type": "Identifier",
+          "name": "item"
+        },
+        "right": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "Identifier",
+            "name": "item"
+          },
+          "property": {
+            "type": "Identifier",
+            "name": "src"
+          },
+          "computed": false
+        }
+      }
+    }
+  ]
+}

lib/parse.js

@@ -447,6 +447,37 @@ module.exports = function parse(input) {
       }
     }
 
+    function consumeMemberExpression(expression, computed) {
+      const parent = findBottomRightParentNode(
+        expressionStatement,
+        shouldBreak
+      );
+
+      switch (parent.type) {
+        case astTypes.EXPRESSION_STATEMENT:
+          parent.expression = new astFactory.MemberExpression(
+            parent.expression,
+            expression,
+            computed
+          );
+          break;
+        case astTypes.BINARY_EXPRESSION:
+        case astTypes.LOGICAL_EXPRESSION:
+          parent.right = new astFactory.MemberExpression(
+            parent.right,
+            expression,
+            computed
+          );
+          break;
+        default:
+          throwError('Unexpected parent.type: ' + parent.type);
+      }
+
+      function shouldBreak(ast) {
+        return ast.paren || ast.type === astTypes.MEMBER_EXPRESSION;
+      }
+    }
+
     function consumeSecondOperator(node) {
       if (secondOperator) {
         if (astFactory.isUnaryExpressionOperator(secondOperator)) {
@@ -461,47 +492,6 @@ module.exports = function parse(input) {
       return node;
     }
 
-    function consumeMemberExpression(expression, computed) {
-      setMemberExpression(expressionStatement);
-
-      function setMemberExpression(node) {
-        switch (node.type) {
-          case astTypes.EXPRESSION_STATEMENT:
-            if (
-              node.expression.type === astTypes.LITERAL ||
-              node.expression.type === astTypes.IDENTIFIER ||
-              node.expression.type === astTypes.MEMBER_EXPRESSION
-            ) {
-              node.expression = new astFactory.MemberExpression(
-                node.expression,
-                expression,
-                computed
-              );
-            } else {
-              setMemberExpression(node.expression);
-            }
-            break;
-          case astTypes.BINARY_EXPRESSION:
-            if (
-              node.right.type === astTypes.LITERAL ||
-              node.right.type === astTypes.IDENTIFIER ||
-              node.right.type === astTypes.MEMBER_EXPRESSION
-            ) {
-              node.right = new astFactory.MemberExpression(
-                node.right,
-                expression,
-                computed
-              );
-            } else {
-              setMemberExpression(node.right);
-            }
-            break;
-          default:
-            throwError('Unexpected node type: ' + node.type);
-        }
-      }
-    }
-
     function getIdentifier() {
       const start = i;
       let code;