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 29 // Test functionality of block scopes. 30 31 // Hoisting of var declarations. 32 function f1() { 33 { 34 var x = 1; 35 var y; 36 } 37 assertEquals(1, x) 38 assertEquals(undefined, y) 39 } 40 for (var j = 0; j < 5; ++j) f1(); 41 %OptimizeFunctionOnNextCall(f1); 42 f1(); 43 assertTrue(%GetOptimizationStatus(f1) != 2); 44 45 // Dynamic lookup in and through block contexts. 46 function f2(one) { 47 var x = one + 1; 48 let y = one + 2; 49 const u = one + 4; 50 class a { static foo() { return one + 6; } } 51 { 52 let z = one + 3; 53 const v = one + 5; 54 class b { static foo() { return one + 7; } } 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 assertEquals(7, eval('a.foo()')); 62 assertEquals(8, eval('b.foo()')); 63 } 64 } 65 66 f2(1); 67 68 // Lookup in and through block contexts. 69 function f3(one) { 70 var x = one + 1; 71 let y = one + 2; 72 const u = one + 4; 73 class a { static foo() { return one + 6; } } 74 { 75 let z = one + 3; 76 const v = one + 5; 77 class b { static foo() { return one + 7; } } 78 assertEquals(1, one); 79 assertEquals(2, x); 80 assertEquals(3, y); 81 assertEquals(4, z); 82 assertEquals(5, u); 83 assertEquals(6, v); 84 assertEquals(7, a.foo()); 85 assertEquals(8, b.foo()); 86 } 87 } 88 for (var j = 0; j < 5; ++j) f3(1); 89 %OptimizeFunctionOnNextCall(f3); 90 f3(1); 91 92 93 94 // Dynamic lookup from closure. 95 function f4(one) { 96 var x = one + 1; 97 let y = one + 2; 98 const u = one + 4; 99 class a { static foo() { return one + 6; } } 100 { 101 let z = one + 3; 102 const v = one + 5; 103 class b { static foo() { return one + 7; } } 104 function f() { 105 assertEquals(1, eval('one')); 106 assertEquals(2, eval('x')); 107 assertEquals(3, eval('y')); 108 assertEquals(4, eval('z')); 109 assertEquals(5, eval('u')); 110 assertEquals(6, eval('v')); 111 assertEquals(7, eval('a.foo()')); 112 assertEquals(8, eval('b.foo()')); 113 } 114 f(); 115 } 116 } 117 f4(1); 118 119 120 // Lookup from closure. 121 function f5(one) { 122 var x = one + 1; 123 let y = one + 2; 124 const u = one + 4; 125 class a { static foo() { return one + 6; } } 126 { 127 let z = one + 3; 128 const v = one + 5; 129 class b { static foo() { return one + 7; } } 130 function f() { 131 assertEquals(1, one); 132 assertEquals(2, x); 133 assertEquals(3, y); 134 assertEquals(4, z); 135 assertEquals(5, u); 136 assertEquals(6, v); 137 assertEquals(7, a.foo()); 138 assertEquals(8, b.foo()); 139 } 140 f(); 141 } 142 } 143 f5(1); 144 145 146 // Return from block. 147 function f6() { 148 let x = 1; 149 const u = 3; 150 { 151 let y = 2; 152 const v = 4; 153 return x + y; 154 } 155 } 156 assertEquals(3, f6(6)); 157 158 159 // Variable shadowing and lookup. 160 function f7(a) { 161 let b = 1; 162 var c = 1; 163 var d = 1; 164 const e = 1; 165 class f { static foo() { return 1; } } 166 { // let variables shadowing argument, let, const, class and var variables 167 let a = 2; 168 let b = 2; 169 let c = 2; 170 let e = 2; 171 let f = 2; 172 assertEquals(2,a); 173 assertEquals(2,b); 174 assertEquals(2,c); 175 assertEquals(2,e); 176 assertEquals(2,f); 177 } 178 { // const variables shadowing argument, let, const and var variables 179 const a = 2; 180 const b = 2; 181 const c = 2; 182 const e = 2; 183 const f = 2; 184 assertEquals(2,a); 185 assertEquals(2,b); 186 assertEquals(2,c); 187 assertEquals(2,e); 188 assertEquals(2,f); 189 } 190 { // class variables shadowing argument, let, const and var variables 191 class a { static foo() { return 2; } } 192 class b { static foo() { return 2; } } 193 class c { static foo() { return 2; } } 194 class d { static foo() { return 2; } } 195 class e { static foo() { return 2; } } 196 class f { static foo() { return 2; } } 197 assertEquals(2,a.foo()); 198 assertEquals(2,b.foo()); 199 assertEquals(2,c.foo()); 200 assertEquals(2,e.foo()); 201 assertEquals(2,f.foo()); 202 } 203 try { 204 throw 'stuff1'; 205 } catch (a) { 206 assertEquals('stuff1',a); 207 // catch variable shadowing argument 208 a = 2; 209 assertEquals(2,a); 210 { 211 // let variable shadowing catch variable 212 let a = 3; 213 assertEquals(3,a); 214 try { 215 throw 'stuff2'; 216 } catch (a) { 217 assertEquals('stuff2',a); 218 // catch variable shadowing let variable 219 a = 4; 220 assertEquals(4,a); 221 } 222 assertEquals(3,a); 223 } 224 assertEquals(2,a); 225 } 226 try { 227 throw 'stuff3'; 228 } catch (c) { 229 // catch variable shadowing var variable 230 assertEquals('stuff3',c); 231 { 232 // const variable shadowing catch variable 233 const c = 3; 234 assertEquals(3,c); 235 } 236 assertEquals('stuff3',c); 237 try { 238 throw 'stuff4'; 239 } catch(c) { 240 assertEquals('stuff4',c); 241 // catch variable shadowing catch variable 242 c = 3; 243 assertEquals(3,c); 244 } 245 (function(c) { 246 // argument shadowing catch variable 247 c = 3; 248 assertEquals(3,c); 249 })(); 250 assertEquals('stuff3', c); 251 (function() { 252 // var variable shadowing catch variable 253 var c = 3; 254 })(); 255 assertEquals('stuff3', c); 256 c = 2; 257 } 258 assertEquals(1,c); 259 (function(a,b,c,e,f) { 260 // arguments shadowing argument, let, const, class and var variable 261 a = 2; 262 b = 2; 263 c = 2; 264 e = 2; 265 f = 2; 266 assertEquals(2,a); 267 assertEquals(2,b); 268 assertEquals(2,c); 269 assertEquals(2,e); 270 assertEquals(2,f); 271 // var variable shadowing var variable 272 var d = 2; 273 })(1,1); 274 assertEquals(1,a); 275 assertEquals(1,b); 276 assertEquals(1,c); 277 assertEquals(1,d); 278 assertEquals(1,e); 279 assertEquals(1,f.foo()); 280 } 281 f7(1); 282 283 284 // Ensure let and const variables are block local 285 // and var variables function local. 286 function f8() { 287 var let_accessors = []; 288 var var_accessors = []; 289 var const_accessors = []; 290 var class_accessors = []; 291 for (var i = 0; i < 10; i++) { 292 let x = i; 293 var y = i; 294 const z = i; 295 class a { static foo() { return x; } } 296 let_accessors[i] = function() { return x; } 297 var_accessors[i] = function() { return y; } 298 const_accessors[i] = function() { return z; } 299 class_accessors[i] = function() { return a; } 300 } 301 for (var j = 0; j < 10; j++) { 302 y = j + 10; 303 assertEquals(j, let_accessors[j]()); 304 assertEquals(y, var_accessors[j]()); 305 assertEquals(j, const_accessors[j]()); 306 assertEquals(j, class_accessors[j]().foo()); 307 } 308 } 309 f8(); 310
