tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

yield-in-object-destr-generator.js (3946B)

      1 /* This Source Code Form is subject to the terms of the Mozilla Public
      2 * License, v. 2.0. If a copy of the MPL was not distributed with this
      3 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
      4 
      5 
      6 // Destructuring binding patterns with var.
      7 assertThrowsInstanceOf(() => eval(`
      8    function* g() {
      9        var {a: yield} = {};
     10    }
     11 `), SyntaxError);
     12 
     13 assertThrowsInstanceOf(() => eval(`
     14    function* g() {
     15        var {yield} = {};
     16    }
     17 `), SyntaxError);
     18 
     19 assertThrowsInstanceOf(() => eval(`
     20    function* g() {
     21        var {yield = 0} = {};
     22    }
     23 `), SyntaxError);
     24 
     25 assertThrowsInstanceOf(() => eval(`
     26    "use strict";
     27    function* g() {
     28        var {a: yield} = {};
     29    }
     30 `), SyntaxError);
     31 
     32 assertThrowsInstanceOf(() => eval(`
     33    "use strict";
     34    function* g() {
     35        var {yield} = {};
     36    }
     37 `), SyntaxError);
     38 
     39 assertThrowsInstanceOf(() => eval(`
     40    "use strict";
     41    function* g() {
     42        var {yield = 0} = {};
     43    }
     44 `), SyntaxError);
     45 
     46 
     47 // Destructuring binding patterns with let.
     48 assertThrowsInstanceOf(() => eval(`
     49    function* g() {
     50        let {a: yield} = {};
     51    }
     52 `), SyntaxError);
     53 
     54 assertThrowsInstanceOf(() => eval(`
     55    function* g() {
     56        let {yield} = {};
     57    }
     58 `), SyntaxError);
     59 
     60 assertThrowsInstanceOf(() => eval(`
     61    function* g() {
     62        let {yield = 0} = {};
     63    }
     64 `), SyntaxError);
     65 
     66 assertThrowsInstanceOf(() => eval(`
     67    "use strict";
     68    function* g() {
     69        let {a: yield} = {};
     70    }
     71 `), SyntaxError);
     72 
     73 assertThrowsInstanceOf(() => eval(`
     74    "use strict";
     75    function* g() {
     76        let {yield} = {};
     77    }
     78 `), SyntaxError);
     79 
     80 assertThrowsInstanceOf(() => eval(`
     81    "use strict";
     82    function* g() {
     83        let {yield = 0} = {};
     84    }
     85 `), SyntaxError);
     86 
     87 
     88 // Destructuring binding patterns with const.
     89 assertThrowsInstanceOf(() => eval(`
     90    function* g() {
     91        const {a: yield} = {};
     92    }
     93 `), SyntaxError);
     94 
     95 assertThrowsInstanceOf(() => eval(`
     96    function* g() {
     97        const {yield} = {};
     98    }
     99 `), SyntaxError);
    100 
    101 assertThrowsInstanceOf(() => eval(`
    102    function* g() {
    103        const {yield = 0} = {};
    104    }
    105 `), SyntaxError);
    106 
    107 assertThrowsInstanceOf(() => eval(`
    108    "use strict";
    109    function* g() {
    110        const {a: yield} = {};
    111    }
    112 `), SyntaxError);
    113 
    114 assertThrowsInstanceOf(() => eval(`
    115    "use strict";
    116    function* g() {
    117        const {yield} = {};
    118    }
    119 `), SyntaxError);
    120 
    121 assertThrowsInstanceOf(() => eval(`
    122    "use strict";
    123    function* g() {
    124        const {yield = 0} = {};
    125    }
    126 `), SyntaxError);
    127 
    128 
    129 // Destructuring binding patterns in parameters.
    130 assertThrowsInstanceOf(() => eval(`
    131    function* g({a: yield} = {}) { }
    132 `), SyntaxError);
    133 
    134 assertThrowsInstanceOf(() => eval(`
    135    function* g({yield} = {}) { }
    136 `), SyntaxError);
    137 
    138 assertThrowsInstanceOf(() => eval(`
    139    function* g({yield = 0} = {}) { }
    140 `), SyntaxError);
    141 
    142 assertThrowsInstanceOf(() => eval(`
    143    "use strict";
    144    function* g({a: yield} = {}) { }
    145 `), SyntaxError);
    146 
    147 assertThrowsInstanceOf(() => eval(`
    148    "use strict";
    149    function* g({yield} = {}) { }
    150 `), SyntaxError);
    151 
    152 assertThrowsInstanceOf(() => eval(`
    153    "use strict";
    154    function* g({yield = 0} = {}) { }
    155 `), SyntaxError);
    156 
    157 
    158 // Destructuring assignment pattern.
    159 assertThrowsInstanceOf(() => eval(`
    160    function* g() {
    161        ({a: yield} = {});
    162    }
    163 `), SyntaxError);
    164 
    165 assertThrowsInstanceOf(() => eval(`
    166    function* g() {
    167        ({yield} = {});
    168    }
    169 `), SyntaxError);
    170 
    171 assertThrowsInstanceOf(() => eval(`
    172    function* g() {
    173        ({yield = 0} = {});
    174    }
    175 `), SyntaxError);
    176 
    177 assertThrowsInstanceOf(() => eval(`
    178    "use strict";
    179    function* g() {
    180        ({a: yield} = {});
    181    }
    182 `), SyntaxError);
    183 
    184 assertThrowsInstanceOf(() => eval(`
    185    "use strict";
    186    function* g() {
    187        ({yield} = {});
    188    }
    189 `), SyntaxError);
    190 
    191 assertThrowsInstanceOf(() => eval(`
    192    "use strict";
    193    function* g() {
    194        ({yield = 0} = {});
    195    }
    196 `), SyntaxError);
    197 
    198 
    199 if (typeof reportCompare === "function")
    200    reportCompare(0, 0, "ok");