| 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-sloppy --harmony-sloppy-let --harmony
-sloppy-function | |
| 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(); | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1858943002:
Remove runtime flags for sloppy mode block scoping features (Closed)
Base URL: https://chromium.googlesource.com/v8/v8.git@master