| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2011 the V8 project authors. All rights reserved. | |
| 2 // Redistribution and use in source and binary forms, with or without | |
| 3 // modification, are permitted provided that the following conditions are | |
| 4 // met: | |
| 5 // | |
| 6 // * Redistributions of source code must retain the above copyright | |
| 7 // notice, this list of conditions and the following disclaimer. | |
| 8 // * Redistributions in binary form must reproduce the above | |
| 9 // copyright notice, this list of conditions and the following | |
| 10 // disclaimer in the documentation and/or other materials provided | |
| 11 // with the distribution. | |
| 12 // * Neither the name of Google Inc. nor the names of its | |
| 13 // contributors may be used to endorse or promote products derived | |
| 14 // from this software without specific prior written permission. | |
| 15 // | |
| 16 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | |
| 17 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | |
| 18 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | |
| 19 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT | |
| 20 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | |
| 21 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT | |
| 22 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, | |
| 23 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY | |
| 24 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | |
| 25 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | |
| 26 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
| 27 | |
| 28 // Flags: --allow-natives-syntax --harmony-scoping | |
| 29 // Test functionality of block scopes. | |
| 30 | |
| 31 "use strict"; | |
| 32 | |
| 33 // Hoisting of var declarations. | |
| 34 function f1() { | |
| 35 { | |
| 36 var x = 1; | |
| 37 var y; | |
| 38 } | |
| 39 assertEquals(1, x) | |
| 40 assertEquals(undefined, y) | |
| 41 } | |
| 42 for (var j = 0; j < 5; ++j) f1(); | |
| 43 %OptimizeFunctionOnNextCall(f1); | |
| 44 f1(); | |
| 45 assertTrue(%GetOptimizationStatus(f1) != 2); | |
| 46 | |
| 47 // Dynamic lookup in and through block contexts. | |
| 48 function f2(one) { | |
| 49 var x = one + 1; | |
| 50 let y = one + 2; | |
| 51 const u = one + 4; | |
| 52 { | |
| 53 let z = one + 3; | |
| 54 const v = one + 5; | |
| 55 assertEquals(1, eval('one')); | |
| 56 assertEquals(2, eval('x')); | |
| 57 assertEquals(3, eval('y')); | |
| 58 assertEquals(4, eval('z')); | |
| 59 assertEquals(5, eval('u')); | |
| 60 assertEquals(6, eval('v')); | |
| 61 } | |
| 62 } | |
| 63 | |
| 64 f2(1); | |
| 65 | |
| 66 // Lookup in and through block contexts. | |
| 67 function f3(one) { | |
| 68 var x = one + 1; | |
| 69 let y = one + 2; | |
| 70 const u = one + 4; | |
| 71 { | |
| 72 let z = one + 3; | |
| 73 const v = one + 5; | |
| 74 assertEquals(1, one); | |
| 75 assertEquals(2, x); | |
| 76 assertEquals(3, y); | |
| 77 assertEquals(4, z); | |
| 78 assertEquals(5, u); | |
| 79 assertEquals(6, v); | |
| 80 } | |
| 81 } | |
| 82 for (var j = 0; j < 5; ++j) f3(1); | |
| 83 %OptimizeFunctionOnNextCall(f3); | |
| 84 f3(1); | |
| 85 assertTrue(%GetOptimizationStatus(f3) != 2); | |
| 86 | |
| 87 | |
| 88 | |
| 89 // Dynamic lookup from closure. | |
| 90 function f4(one) { | |
| 91 var x = one + 1; | |
| 92 let y = one + 2; | |
| 93 const u = one + 4; | |
| 94 { | |
| 95 let z = one + 3; | |
| 96 const v = one + 5; | |
| 97 function f() { | |
| 98 assertEquals(1, eval('one')); | |
| 99 assertEquals(2, eval('x')); | |
| 100 assertEquals(3, eval('y')); | |
| 101 assertEquals(4, eval('z')); | |
| 102 assertEquals(5, eval('u')); | |
| 103 assertEquals(6, eval('v')); | |
| 104 } | |
| 105 f(); | |
| 106 } | |
| 107 } | |
| 108 f4(1); | |
| 109 | |
| 110 | |
| 111 // Lookup from closure. | |
| 112 function f5(one) { | |
| 113 var x = one + 1; | |
| 114 let y = one + 2; | |
| 115 const u = one + 4; | |
| 116 { | |
| 117 let z = one + 3; | |
| 118 const v = one + 5; | |
| 119 function f() { | |
| 120 assertEquals(1, one); | |
| 121 assertEquals(2, x); | |
| 122 assertEquals(3, y); | |
| 123 assertEquals(4, z); | |
| 124 assertEquals(5, u); | |
| 125 assertEquals(6, v); | |
| 126 } | |
| 127 f(); | |
| 128 } | |
| 129 } | |
| 130 f5(1); | |
| 131 | |
| 132 | |
| 133 // Return from block. | |
| 134 function f6() { | |
| 135 let x = 1; | |
| 136 const u = 3; | |
| 137 { | |
| 138 let y = 2; | |
| 139 const v = 4; | |
| 140 return x + y; | |
| 141 } | |
| 142 } | |
| 143 assertEquals(3, f6(6)); | |
| 144 | |
| 145 | |
| 146 // Variable shadowing and lookup. | |
| 147 function f7(a) { | |
| 148 let b = 1; | |
| 149 var c = 1; | |
| 150 var d = 1; | |
| 151 const e = 1; | |
| 152 { // let variables shadowing argument, let, const and var variables | |
| 153 let a = 2; | |
| 154 let b = 2; | |
| 155 let c = 2; | |
| 156 let e = 2; | |
| 157 assertEquals(2,a); | |
| 158 assertEquals(2,b); | |
| 159 assertEquals(2,c); | |
| 160 assertEquals(2,e); | |
| 161 } | |
| 162 { // const variables shadowing argument, let, const and var variables | |
| 163 const a = 2; | |
| 164 const b = 2; | |
| 165 const c = 2; | |
| 166 const e = 2; | |
| 167 assertEquals(2,a); | |
| 168 assertEquals(2,b); | |
| 169 assertEquals(2,c); | |
| 170 assertEquals(2,e); | |
| 171 } | |
| 172 try { | |
| 173 throw 'stuff1'; | |
| 174 } catch (a) { | |
| 175 assertEquals('stuff1',a); | |
| 176 // catch variable shadowing argument | |
| 177 a = 2; | |
| 178 assertEquals(2,a); | |
| 179 { | |
| 180 // let variable shadowing catch variable | |
| 181 let a = 3; | |
| 182 assertEquals(3,a); | |
| 183 try { | |
| 184 throw 'stuff2'; | |
| 185 } catch (a) { | |
| 186 assertEquals('stuff2',a); | |
| 187 // catch variable shadowing let variable | |
| 188 a = 4; | |
| 189 assertEquals(4,a); | |
| 190 } | |
| 191 assertEquals(3,a); | |
| 192 } | |
| 193 assertEquals(2,a); | |
| 194 } | |
| 195 try { | |
| 196 throw 'stuff3'; | |
| 197 } catch (c) { | |
| 198 // catch variable shadowing var variable | |
| 199 assertEquals('stuff3',c); | |
| 200 { | |
| 201 // const variable shadowing catch variable | |
| 202 const c = 3; | |
| 203 assertEquals(3,c); | |
| 204 } | |
| 205 assertEquals('stuff3',c); | |
| 206 try { | |
| 207 throw 'stuff4'; | |
| 208 } catch(c) { | |
| 209 assertEquals('stuff4',c); | |
| 210 // catch variable shadowing catch variable | |
| 211 c = 3; | |
| 212 assertEquals(3,c); | |
| 213 } | |
| 214 (function(c) { | |
| 215 // argument shadowing catch variable | |
| 216 c = 3; | |
| 217 assertEquals(3,c); | |
| 218 })(); | |
| 219 assertEquals('stuff3', c); | |
| 220 (function() { | |
| 221 // var variable shadowing catch variable | |
| 222 var c = 3; | |
| 223 })(); | |
| 224 assertEquals('stuff3', c); | |
| 225 c = 2; | |
| 226 } | |
| 227 assertEquals(1,c); | |
| 228 (function(a,b,c,e) { | |
| 229 // arguments shadowing argument, let, const and var variable | |
| 230 a = 2; | |
| 231 b = 2; | |
| 232 c = 2; | |
| 233 e = 2; | |
| 234 assertEquals(2,a); | |
| 235 assertEquals(2,b); | |
| 236 assertEquals(2,c); | |
| 237 assertEquals(2,e); | |
| 238 // var variable shadowing var variable | |
| 239 var d = 2; | |
| 240 })(1,1); | |
| 241 assertEquals(1,a); | |
| 242 assertEquals(1,b); | |
| 243 assertEquals(1,c); | |
| 244 assertEquals(1,d); | |
| 245 assertEquals(1,e); | |
| 246 } | |
| 247 f7(1); | |
| 248 | |
| 249 | |
| 250 // Ensure let and const variables are block local | |
| 251 // and var variables function local. | |
| 252 function f8() { | |
| 253 var let_accessors = []; | |
| 254 var var_accessors = []; | |
| 255 var const_accessors = []; | |
| 256 for (var i = 0; i < 10; i++) { | |
| 257 let x = i; | |
| 258 var y = i; | |
| 259 const z = i; | |
| 260 let_accessors[i] = function() { return x; } | |
| 261 var_accessors[i] = function() { return y; } | |
| 262 const_accessors[i] = function() { return z; } | |
| 263 } | |
| 264 for (var j = 0; j < 10; j++) { | |
| 265 y = j + 10; | |
| 266 assertEquals(j, let_accessors[j]()); | |
| 267 assertEquals(y, var_accessors[j]()); | |
| 268 assertEquals(j, const_accessors[j]()); | |
| 269 } | |
| 270 } | |
| 271 f8(); | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1007783002:
Remove --harmony-scoping flag. (Closed)
Base URL: https://chromium.googlesource.com/v8/v8.git@master