Destructuring assignment rest element could include simple parenthesized target

FIX acornjs#872

Author: 成仕伟

acorn/src/expression.js

@@ -750,15 +750,6 @@ pp.parseProperty = function(isPattern, refDestructuringErrors) {
       }
       return this.finishNode(prop, "RestElement")
     }
-    // To disallow parenthesized identifier via `this.toAssignable()`.
-    if (this.type === tt.parenL && refDestructuringErrors) {
-      if (refDestructuringErrors.parenthesizedAssign < 0) {
-        refDestructuringErrors.parenthesizedAssign = this.start
-      }
-      if (refDestructuringErrors.parenthesizedBind < 0) {
-        refDestructuringErrors.parenthesizedBind = this.start
-      }
-    }
     // Parse argument.
     prop.argument = this.parseMaybeAssign(false, refDestructuringErrors)
     // To disallow trailing comma via `this.toAssignable()`.

acorn/src/parseutil.js

@@ -127,7 +127,7 @@ pp.checkPatternErrors = function(refDestructuringErrors, isAssign) {
   if (refDestructuringErrors.trailingComma > -1)
     this.raiseRecoverable(refDestructuringErrors.trailingComma, "Comma is not permitted after the rest element")
   let parens = isAssign ? refDestructuringErrors.parenthesizedAssign : refDestructuringErrors.parenthesizedBind
-  if (parens > -1) this.raiseRecoverable(parens, "Parenthesized pattern")
+  if (parens > -1) this.raiseRecoverable(parens, isAssign ? "Assigning to rvalue" : "Parenthesized pattern")
 }
 
 pp.checkExpressionErrors = function(refDestructuringErrors, andThrow) {

test/tests-harmony.js

@@ -13089,7 +13089,7 @@ testFail("[v] += ary", "Assigning to rvalue (1:0)", {ecmaVersion: 6});
 
 testFail("[2] = 42", "Assigning to rvalue (1:1)", {ecmaVersion: 6});
 
-testFail("({ obj:20 }) = 42", "Parenthesized pattern (1:0)", {ecmaVersion: 6});
+testFail("({ obj:20 }) = 42", "Assigning to rvalue (1:0)", {ecmaVersion: 6});
 
 testFail("( { get x() {} } = 0)", "Object pattern can't contain getter or setter (1:8)", {ecmaVersion: 6});
 
@@ -16159,7 +16159,7 @@ testFail("'use strict'; bar: function x() {}", "Unexpected token (1:19)", {ecmaV
 testFail("'use strict'; bar: function* x() {}", "Unexpected token (1:19)", {ecmaVersion: 6})
 testFail("bar: function* x() {}", "Unexpected token (1:13)", {ecmaVersion: 6})
 
-testFail("({x, y}) = {}", "Parenthesized pattern (1:0)", {ecmaVersion: 6})
+testFail("({x, y}) = {}", "Assigning to rvalue (1:0)", {ecmaVersion: 6})
 
 test("[x, (y), {z, u: (v)}] = foo", {}, {ecmaVersion: 6})
 

test/tests-rest-spread-properties.js

@@ -813,6 +813,119 @@ test("({a:b,...obj}) => {}", {
   "sourceType": "script"
 }, { ecmaVersion: 9 })
 
+test("({...(obj)} = foo)", {
+  type: "Program",
+  start: 0,
+  end: 18,
+  loc: {
+    start: {
+      line: 1,
+      column: 0
+    },
+    end: {
+      line: 1,
+      column: 18
+    }
+  },
+  body: [
+    {
+      type: "ExpressionStatement",
+      start: 0,
+      end: 18,
+      loc: {
+        start: {
+          line: 1,
+          column: 0
+        },
+        end: {
+          line: 1,
+          column: 18
+        }
+      },
+      expression: {
+        type: "AssignmentExpression",
+        start: 1,
+        end: 17,
+        loc: {
+          start: {
+            line: 1,
+            column: 1
+          },
+          end: {
+            line: 1,
+            column: 17
+          }
+        },
+        operator: "=",
+        left: {
+          type: "ObjectPattern",
+          start: 1,
+          end: 11,
+          loc: {
+            start: {
+              line: 1,
+              column: 1
+            },
+            end: {
+              line: 1,
+              column: 11
+            }
+          },
+          properties: [
+            {
+              type: "RestElement",
+              start: 2,
+              end: 10,
+              loc: {
+                start: {
+                  line: 1,
+                  column: 2
+                },
+                end: {
+                  line: 1,
+                  column: 10
+                }
+              },
+              argument: {
+                type: "Identifier",
+                start: 6,
+                end: 9,
+                loc: {
+                  start: {
+                    line: 1,
+                    column: 6
+                  },
+                  end: {
+                    line: 1,
+                    column: 9
+                  }
+                },
+                name: "obj"
+              }
+            }
+          ]
+        },
+        right: {
+          type: "Identifier",
+          start: 14,
+          end: 17,
+          loc: {
+            start: {
+              line: 1,
+              column: 14
+            },
+            end: {
+              line: 1,
+              column: 17
+            }
+          },
+          name: "foo"
+        }
+      }
+    }
+  ],
+}, { ecmaVersion: 9, locations: true })
+
 testFail("let {...obj1,} = foo", "Comma is not permitted after the rest element (1:12)", { ecmaVersion: 9 })
 testFail("let {...obj1,a} = foo", "Comma is not permitted after the rest element (1:12)", { ecmaVersion: 9 })
 testFail("let {...obj1,...obj2} = foo", "Comma is not permitted after the rest element (1:12)", { ecmaVersion: 9 })
@@ -823,8 +936,7 @@ testFail("let {...[a,b]} = foo", "Unexpected token (1:8)", { ecmaVersion: 9 })
 testFail("({...obj1,} = foo)", "Comma is not permitted after the rest element (1:9)", { ecmaVersion: 9 })
 testFail("({...obj1,a} = foo)", "Comma is not permitted after the rest element (1:9)", { ecmaVersion: 9 })
 testFail("({...obj1,...obj2} = foo)", "Comma is not permitted after the rest element (1:9)", { ecmaVersion: 9 })
-testFail("({...(obj)} = foo)", "Parenthesized pattern (1:5)", { ecmaVersion: 9 })
-testFail("({...(a,b)} = foo)", "Parenthesized pattern (1:5)", { ecmaVersion: 9 })
+testFail("({...(a,b)} = foo)", "Assigning to rvalue (1:5)", { ecmaVersion: 9 })
 testFail("({...{a,b}} = foo)", "Unexpected token (1:5)", { ecmaVersion: 9 })
 testFail("({...[a,b]} = foo)", "Unexpected token (1:5)", { ecmaVersion: 9 })
 testFail("({...obj} = foo)", "Unexpected token (1:2)", { ecmaVersion: 8 })

test/tests.js

@@ -27174,7 +27174,7 @@ testFail("func() = 4",
          "Assigning to rvalue (1:0)");
 
 testFail("(1 + 1) = 10",
-         "Parenthesized pattern (1:0)");
+         "Assigning to rvalue (1:0)");
 
 testFail("1++",
          "Assigning to rvalue (1:0)");
@@ -27189,7 +27189,7 @@ testFail("--1",
          "Assigning to rvalue (1:2)");
 
 testFail("for((1 + 1) in list) process(x);",
-         "Parenthesized pattern (1:4)");
+         "Assigning to rvalue (1:4)");
 
 testFail("[",
          "Unexpected token (1:1)");
@@ -29437,7 +29437,7 @@ testFail("for (x \\u006ff y) {}", "Unexpected token (1:7)", {ecmaVersion: 6})
 testFail("function x () { new.ta\\u0072get }", "'new.target' must not contain escaped characters (1:16)", {ecmaVersion: 6})
 testFail("class X { st\\u0061tic y() {} }", "Unexpected token (1:22)", {ecmaVersion: 6})
 
-testFail("(x=1)=2", "Parenthesized pattern (1:0)")
+testFail("(x=1)=2", "Assigning to rvalue (1:0)")
 testFail("(x=1)=2", "Assigning to rvalue (1:1)", {ecmaVersion: 6})
 
 test("(foo = [])[0] = 4;", {})