Don't extract rest elements from nested expressions (#7364)

* Don't extract rest elements from nested expressions

* Node 4

packages/babel-plugin-proposal-object-rest-spread/src/index.js

@@ -10,15 +10,30 @@ export default function(api, opts) {
 
   function hasRestElement(path) {
     let foundRestElement = false;
-    path.traverse({
+    visitRestElements(path, () => {
-      RestElement() {
       foundRestElement = true;
       path.stop();
-      },
     });
     return foundRestElement;
   }
 
+  function visitRestElements(path, visitor) {
+    path.traverse({
+      Expression(path) {
+        const parentType = path.parent.type;
+        if (
+          (parentType == "AssignmentPattern" && path.key === "right") ||
+          (parentType == "ObjectProperty" &&
+            path.parent.computed &&
+            path.key === "key")
+        ) {
+          path.skip();
+        }
+      },
+      RestElement: visitor,
+    });
+  }
+
   function hasSpread(node) {
     for (const prop of node.properties) {
       if (t.isSpreadElement(prop)) {
@@ -147,16 +162,9 @@ export default function(api, opts) {
         }
 
         let insertionPath = path;
+        const originalPath = path;
 
-        path.get("id").traverse(
+        visitRestElements(path.get("id"), path => {
-          {
-            // If there's a default-value AssignmentPattern within the ObjectPattern,
-            // we should not traverse into it, lest we end up in another function body.
-            // (The parent traversal will handle it.)
-            AssignmentPattern(path) {
-              path.skip();
-            },
-            RestElement(path) {
           if (!path.parentPath.isObjectPattern()) {
             // Return early if the parent is not an ObjectPattern, but
             // (for example) an ArrayPattern or Function, because that
@@ -168,33 +176,30 @@ export default function(api, opts) {
             // skip single-property case, e.g.
             // const { ...x } = foo();
             // since the RHS will not be duplicated
-                this.originalPath.node.id.properties.length > 1 &&
+            originalPath.node.id.properties.length > 1 &&
-                !t.isIdentifier(this.originalPath.node.init)
+            !t.isIdentifier(originalPath.node.init)
           ) {
             // const { a, ...b } = foo();
             // to avoid calling foo() twice, as a first step convert it to:
             // const _foo = foo(),
             //       { a, ...b } = _foo;
             const initRef = path.scope.generateUidIdentifierBasedOnNode(
-                  this.originalPath.node.init,
+              originalPath.node.init,
               "ref",
             );
             // insert _foo = foo()
-                this.originalPath.insertBefore(
+            originalPath.insertBefore(
-                  t.variableDeclarator(initRef, this.originalPath.node.init),
+              t.variableDeclarator(initRef, originalPath.node.init),
             );
             // replace foo() with _foo
-                this.originalPath.replaceWith(
+            originalPath.replaceWith(
-                  t.variableDeclarator(
+              t.variableDeclarator(originalPath.node.id, t.cloneNode(initRef)),
-                    this.originalPath.node.id,
-                    t.cloneNode(initRef),
-                  ),
             );
 
             return;
           }
 
-              let ref = this.originalPath.node.init;
+          let ref = originalPath.node.init;
           const refPropertyPath = [];
           let kind;
 
@@ -237,24 +242,22 @@ export default function(api, opts) {
           if (objectPatternPath.node.properties.length === 0) {
             objectPatternPath
               .findParent(
-                    path =>
+                path => path.isObjectProperty() || path.isVariableDeclarator(),
-                      path.isObjectProperty() || path.isVariableDeclarator(),
               )
               .remove();
           }
-            },
+        });
-          },
-          {
-            originalPath: path,
-          },
-        );
       },
       // taken from transform-destructuring/src/index.js#visitor
       // export var { a, ...b } = c;
       ExportNamedDeclaration(path) {
         const declaration = path.get("declaration");
         if (!declaration.isVariableDeclaration()) return;
-        if (!hasRestElement(declaration)) return;
+
+        const hasRest = declaration
+          .get("declarations")
+          .some(path => hasRestElement(path.get("id")));
+        if (!hasRest) return;
 
         const specifiers = [];
 

packages/babel-plugin-proposal-object-rest-spread/test/fixtures/object-rest/nested-computed-key/input.js

@@ -0,0 +1,6 @@
+const {
+  [({ ...rest }) => {
+    let { ...b } = {};
+  }]: a,
+  [({ ...d } = {})]: c,
+} = {};

packages/babel-plugin-proposal-object-rest-spread/test/fixtures/object-rest/nested-computed-key/output.js

@@ -0,0 +1,9 @@
+var _ref2;
+
+const {
+  [(_ref) => {
+    let rest = babelHelpers.objectWithoutProperties(_ref, []);
+    let b = babelHelpers.objectWithoutProperties({}, []);
+  }]: a,
+  [(_ref2 = {}, ({} = _ref2), d = babelHelpers.objectWithoutProperties(_ref2, []), _ref2)]: c
+} = {};

packages/babel-plugin-proposal-object-rest-spread/test/fixtures/object-rest/nested-default-value/input.js

@@ -0,0 +1,6 @@
+const {
+  a = ({ ...rest }) => {
+    let { ...b } = {};
+  },
+  c = ({ ...d } = {}),
+} = {};

packages/babel-plugin-proposal-object-rest-spread/test/fixtures/object-rest/nested-default-value/output.js

@@ -0,0 +1,9 @@
+var _ref2;
+
+const {
+  a = (_ref) => {
+    let rest = babelHelpers.objectWithoutProperties(_ref, []);
+    let b = babelHelpers.objectWithoutProperties({}, []);
+  },
+  c = (_ref2 = {}, ({} = _ref2), d = babelHelpers.objectWithoutProperties(_ref2, []), _ref2)
+} = {};

packages/babel-plugin-proposal-object-rest-spread/test/fixtures/object-rest/nested-order/exec.js

@@ -0,0 +1,21 @@
+var result = "";
+
+var obj = {
+  get foo() {
+    result += "foo"
+  },
+  a: {
+    get bar() {
+      result += "bar";
+    }
+  },
+  b: {
+    get baz() {
+      result += "baz";
+    }
+  }
+};
+
+var { a: { ...bar }, b: { ...baz }, ...foo } = obj;
+
+assert.strictEqual(result, "barbazfoo");

packages/babel-plugin-proposal-object-rest-spread/test/fixtures/object-rest/nested-order/input.js

@@ -0,0 +1 @@
+const { a: { ...bar }, b: { ...baz }, ...foo } = obj;

packages/babel-plugin-proposal-object-rest-spread/test/fixtures/object-rest/nested-order/output.js

@@ -0,0 +1,3 @@
+const bar = babelHelpers.objectWithoutProperties(obj.a, []),
+      baz = babelHelpers.objectWithoutProperties(obj.b, []),
+      foo = babelHelpers.objectWithoutProperties(obj, []);