Parse error with object destructuring inside for loop initializer.

[Luni-4]

When I tried to parse this code:

async function *fn() {
  for await (var { w: { x, y, z } = { x: 4, y: 5, z: 6 } } of asyncIter) {
    assert.sameValue(x, 4);
    assert.sameValue(y, 5);
    assert.sameValue(z, 6);

    assert.throws(ReferenceError, function() {
      w;
    });

    iterCount += 1;
  }
}

fn().next()
  .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
  .then($DONE, $DONE);

I got the following AST:

(program [0, 0] - [13, 0]
  (ERROR [0, 0] - [12, 1]
    (identifier [0, 16] - [0, 18])
    (formal_parameters [0, 18] - [0, 20])
    (ERROR [1, 19] - [1, 35]
      (pair_pattern [1, 19] - [1, 33]
        key: (property_identifier [1, 19] - [1, 20])
        value: (object_pattern [1, 22] - [1, 33]
          (shorthand_property_identifier_pattern [1, 24] - [1, 25])
          (shorthand_property_identifier_pattern [1, 27] - [1, 28])
          (shorthand_property_identifier_pattern [1, 30] - [1, 31]))))
    (object_pattern [1, 36] - [12, 1]
      (ERROR [1, 38] - [11, 3]
        (property_identifier [1, 38] - [1, 39])
        (number [1, 41] - [1, 42])
        (ERROR [1, 44] - [1, 48]
          (property_identifier [1, 44] - [1, 45])
          (number [1, 47] - [1, 48]))
        (pair_pattern [1, 50] - [1, 71]
          key: (property_identifier [1, 50] - [1, 51])
          (ERROR [1, 53] - [1, 61]
            (number [1, 53] - [1, 54]))
          value: (identifier [1, 62] - [1, 71]))
        (object_pattern [1, 73] - [11, 3]
          (ERROR [2, 4] - [2, 21]
            (identifier [2, 4] - [2, 10])
            (identifier [2, 11] - [2, 20]))
          (shorthand_property_identifier_pattern [2, 21] - [2, 22])
          (ERROR [2, 24] - [3, 21]
            (number [2, 24] - [2, 25])
            (identifier [3, 4] - [3, 10])
            (identifier [3, 11] - [3, 20]))
          (shorthand_property_identifier_pattern [3, 21] - [3, 22])
          (ERROR [3, 24] - [4, 21]
            (number [3, 24] - [3, 25])
            (identifier [4, 4] - [4, 10])
            (identifier [4, 11] - [4, 20]))
          (shorthand_property_identifier_pattern [4, 21] - [4, 22])
          (ERROR [4, 24] - [6, 18]
            (number [4, 24] - [4, 25])
            (identifier [6, 4] - [6, 10])
            (identifier [6, 11] - [6, 17]))
          (shorthand_property_identifier_pattern [6, 18] - [6, 32])
          (ERROR [6, 34] - [10, 19]
            (identifier [6, 34] - [6, 42])
            (object_pattern [6, 45] - [8, 5]
              (shorthand_property_identifier_pattern [7, 6] - [7, 7])
              (ERROR [7, 7] - [7, 8]))
            (identifier [10, 4] - [10, 13])
            (number [10, 17] - [10, 18])))))))

[patrickt]

It looks like the fault lies in the combination of object destructuring inside a for-await loop’s initializer, but I’m not sure where it’s going wrong, given that we appear to handle this case in the grammar.

[Luni-4]

Thanks for changing the wrong title! :)

I found another example, perhaps it could help a little more.

async function fn() {
  for await ({ x: xCover = (0, function() {}), x: cover = (function() {}) } of [{}]) {
    assert.notSameValue(xCover.name, 'xCover');

    verifyProperty(cover, 'name', {
      enumerable: false,
      writable: false,
      configurable: true,
      value: 'cover'
    });
    iterCount += 1;
  }

AST:

(program [0, 0] - [12, 0]
  (function_declaration [0, 0] - [11, 3]
    name: (identifier [0, 15] - [0, 17])
    parameters: (formal_parameters [0, 17] - [0, 19])
    body: (statement_block [0, 20] - [11, 3]
      (ERROR [1, 2] - [9, 6]
        (call_expression [1, 13] - [9, 6]
          function: (call_expression [1, 13] - [2, 46]
            function: (member_expression [1, 13] - [2, 23]
              object: (subscript_expression [1, 13] - [1, 83]
                object: (object [1, 13] - [1, 75]
                  (pair [1, 15] - [1, 45]
                    key: (property_identifier [1, 15] - [1, 16])
                    value: (assignment_expression [1, 18] - [1, 45]
                      left: (identifier [1, 18] - [1, 24])
                      right: (parenthesized_expression [1, 27] - [1, 45]
                        (sequence_expression [1, 28] - [1, 44]
                          left: (number [1, 28] - [1, 29])
                          right: (function [1, 31] - [1, 44]
                            parameters: (formal_parameters [1, 39] - [1, 41])
                            body: (statement_block [1, 42] - [1, 44]))))))
                  (pair [1, 47] - [1, 73]
                    key: (property_identifier [1, 47] - [1, 48])
                    value: (assignment_expression [1, 50] - [1, 73]
                      left: (identifier [1, 50] - [1, 55])
                      right: (parenthesized_expression [1, 58] - [1, 73]
                        (function [1, 59] - [1, 72]
                          parameters: (formal_parameters [1, 67] - [1, 69])
                          body: (statement_block [1, 70] - [1, 72]))))))
                (ERROR [1, 76] - [1, 78])
                index: (object [1, 80] - [1, 82]))
              (ERROR [1, 83] - [2, 10]
                (identifier [2, 4] - [2, 10]))
              property: (property_identifier [2, 11] - [2, 23]))
            arguments: (arguments [2, 23] - [2, 46]
              (member_expression [2, 24] - [2, 35]
                object: (identifier [2, 24] - [2, 30])
                property: (property_identifier [2, 31] - [2, 35]))
              (string [2, 37] - [2, 45])))
          (ERROR [2, 46] - [4, 18]
            (identifier [4, 4] - [4, 18]))
          arguments: (arguments [4, 18] - [9, 6]
            (identifier [4, 19] - [4, 24])
            (string [4, 26] - [4, 32])
            (object [4, 34] - [9, 5]
              (pair [5, 6] - [5, 23]
                key: (property_identifier [5, 6] - [5, 16])
                value: (false [5, 18] - [5, 23]))
              (pair [6, 6] - [6, 21]
                key: (property_identifier [6, 6] - [6, 14])
                value: (false [6, 16] - [6, 21]))
              (pair [7, 6] - [7, 24]
                key: (property_identifier [7, 6] - [7, 18])
                value: (true [7, 20] - [7, 24]))
              (pair [8, 6] - [8, 20]
                key: (property_identifier [8, 6] - [8, 11])
                value: (string [8, 13] - [8, 20]))))))
      (empty_statement [9, 6] - [9, 7])
      (expression_statement [10, 4] - [10, 19]
        (augmented_assignment_expression [10, 4] - [10, 18]
          left: (identifier [10, 4] - [10, 13])
          right: (number [10, 17] - [10, 18]))))))