feat(parse): ✨SequenceExpression

Author: vivaxy

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

@@ -0,0 +1 @@
+1,2

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

@@ -0,0 +1,21 @@
+{
+  "type": "Program",
+  "body": [
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "SequenceExpression",
+        "expressions": [
+          {
+            "type": "Literal",
+            "value": 1
+          },
+          {
+            "type": "Literal",
+            "value": 2
+          }
+        ]
+      }
+    }
+  ]
+}

lib/__tests__/fixtures/parse/sequence-expression-001/input.js

@@ -0,0 +1 @@
+1,2===1

lib/__tests__/fixtures/parse/sequence-expression-001/output.json

@@ -0,0 +1,29 @@
+{
+  "type": "Program",
+  "body": [
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "SequenceExpression",
+        "expressions": [
+          {
+            "type": "Literal",
+            "value": 1
+          },
+          {
+            "type": "BinaryExpression",
+            "operator": "===",
+            "left": {
+              "type": "Literal",
+              "value": 2
+            },
+            "right": {
+              "type": "Literal",
+              "value": 1
+            }
+          }
+        ]
+      }
+    }
+  ]
+}

lib/parse.js

@@ -106,12 +106,8 @@ module.exports = function parse(input) {
         /**
          * (a, b)
          */
-        let exprs = [];
-        while (i < _endIndex) {
-          const expr = parseExpressionStatement(i + 1, _endIndex).expression;
-          exprs.push(expr);
-        }
-        consumeParenNodes(exprs);
+        const expr = parseExpressionStatement(i + 1, _endIndex).expression;
+        consumeParenNodes(expr);
         i = _endIndex + 1;
         continue;
       }
@@ -325,22 +321,30 @@ module.exports = function parse(input) {
         setPostfixUpdateOperator(expressionStatement, operator);
         operator = null;
       }
+
+      // support sequence expression
+      if (input.charCodeAt(i - 1) === codes[',']) {
+        // is sequence expression
+        expressionStatement.expression = new astFactory.SequenceExpression([
+          expressionStatement.expression,
+        ]);
+        while (i < endIndex) {
+          const expr = parseExpressionStatement(i, endIndex);
+          expressionStatement.expression.expressions.push(expr.expression);
+        }
+      }
     }
 
-    function consumeParenNodes(nodes) {
+    function consumeParenNodes(expr) {
       if (
         operator === null &&
         secondOperator === null &&
         expressionStatement !== null
       ) {
-        return consumeCallExpression(nodes);
-      }
-      if (nodes.length > 1) {
-        throw new Error('???');
+        return consumeCallExpression(expr);
       }
-      const node = nodes[0];
-      node.paren = true;
-      return consumeNode(node);
+      expr.paren = true;
+      return consumeNode(expr);
     }
 
     function consumeNode(node) {
@@ -377,7 +381,13 @@ module.exports = function parse(input) {
       expressionStatement.expression = expr;
     }
 
-    function consumeCallExpression(exprs) {
+    function consumeCallExpression(expr) {
+      let exprs = [];
+      if (expr.type === astTypes.SEQUENCE_EXPRESSION) {
+        exprs = expr.expressions;
+      } else {
+        exprs = [expr];
+      }
       expressionStatement.expression = new astFactory.CallExpression(
         expressionStatement.expression,
         exprs
@@ -564,6 +574,17 @@ module.exports = function parse(input) {
       );
       consumeNode(arrayExpression);
     }
+
+    function consumeSequenceExpression(startIndex) {
+      expressionStatement.expression = new astFactory.SequenceExpression([
+        expressionStatement.expression,
+      ]);
+      while (startIndex < input.length) {
+        expressionStatement.expression.expressions.push(
+          parseExpressionStatement(startIndex, input.length)
+        );
+      }
+    }
   }
 };