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 function CheckStrictMode(code, exception) { 29 assertDoesNotThrow(code); 30 assertThrows("'use strict';\n" + code, exception); 31 assertThrows('"use strict";\n' + code, exception); 32 assertDoesNotThrow("\ 33 function outer() {\ 34 function inner() {\n" 35 + code + 36 "\n}\ 37 }"); 38 assertThrows("\ 39 function outer() {\ 40 'use strict';\ 41 function inner() {\n" 42 + code + 43 "\n}\ 44 }", exception); 45 } 46 47 function CheckFunctionConstructorStrictMode() { 48 var args = []; 49 for (var i = 0; i < arguments.length; i ++) { 50 args[i] = arguments[i]; 51 } 52 // Create non-strict function. No exception. 53 args[arguments.length] = ""; 54 assertDoesNotThrow(function() { 55 Function.apply(this, args); 56 }); 57 // Create strict mode function. Exception expected. 58 args[arguments.length] = "'use strict';"; 59 assertThrows(function() { 60 Function.apply(this, args); 61 }, SyntaxError); 62 } 63 64 // Incorrect 'use strict' directive. 65 (function UseStrictEscape() { 66 "use\\x20strict"; 67 with ({}) {}; 68 })(); 69 70 // 'use strict' in non-directive position. 71 (function UseStrictNonDirective() { 72 void(0); 73 "use strict"; 74 with ({}) {}; 75 })(); 76 77 // Multiple directives, including "use strict". 78 assertThrows('\ 79 "directive 1";\ 80 "another directive";\ 81 "use strict";\ 82 "directive after strict";\ 83 "and one more";\ 84 with({}) {}', SyntaxError); 85 86 // 'with' disallowed in strict mode. 87 CheckStrictMode("with({}) {}", SyntaxError); 88 89 // Function named 'eval'. 90 CheckStrictMode("function eval() {}", SyntaxError); 91 92 // Function named 'arguments'. 93 CheckStrictMode("function arguments() {}", SyntaxError); 94 95 // Function parameter named 'eval'. 96 CheckStrictMode("function foo(a, b, eval, c, d) {}", SyntaxError); 97 98 // Function parameter named 'arguments'. 99 CheckStrictMode("function foo(a, b, arguments, c, d) {}", SyntaxError); 100 101 // Property accessor parameter named 'eval'. 102 CheckStrictMode("var o = { set foo(eval) {} }", SyntaxError); 103 104 // Property accessor parameter named 'arguments'. 105 CheckStrictMode("var o = { set foo(arguments) {} }", SyntaxError); 106 107 // Duplicate function parameter name. 108 CheckStrictMode("function foo(a, b, c, d, b) {}", SyntaxError); 109 110 // Function constructor: eval parameter name. 111 CheckFunctionConstructorStrictMode("eval"); 112 113 // Function constructor: arguments parameter name. 114 CheckFunctionConstructorStrictMode("arguments"); 115 116 // Function constructor: duplicate parameter name. 117 CheckFunctionConstructorStrictMode("a", "b", "c", "b"); 118 CheckFunctionConstructorStrictMode("a,b,c,b"); 119 120 // catch(eval) 121 CheckStrictMode("try{}catch(eval){};", SyntaxError); 122 123 // catch(arguments) 124 CheckStrictMode("try{}catch(arguments){};", SyntaxError); 125 126 // var eval 127 CheckStrictMode("var eval;", SyntaxError); 128 129 // var arguments 130 CheckStrictMode("var arguments;", SyntaxError); 131 132 // Strict mode applies to the function in which the directive is used.. 133 assertThrows('\ 134 function foo(eval) {\ 135 "use strict";\ 136 }', SyntaxError); 137 138 // Strict mode doesn't affect the outer stop of strict code. 139 (function NotStrict(eval) { 140 function Strict() { 141 "use strict"; 142 } 143 with ({}) {}; 144 })(); 145 146 // Octal literal 147 CheckStrictMode("var x = 012"); 148 CheckStrictMode("012"); 149 CheckStrictMode("'Hello octal\\032'"); 150 CheckStrictMode("function octal() { return 012; }"); 151 CheckStrictMode("function octal() { return '\\032'; }"); 152 153 (function ValidEscape() { 154 "use strict"; 155 var x = '\0'; 156 var y = "\0"; 157 })(); 158 159 // Octal before "use strict" 160 assertThrows('\ 161 function strict() {\ 162 "octal\\032directive";\ 163 "use strict";\ 164 }', SyntaxError); 165 166 // Duplicate data properties. 167 CheckStrictMode("var x = { dupe : 1, nondupe: 3, dupe : 2 };", SyntaxError); 168 CheckStrictMode("var x = { '1234' : 1, '2345' : 2, '1234' : 3 };", SyntaxError); 169 CheckStrictMode("var x = { '1234' : 1, '2345' : 2, 1234 : 3 };", SyntaxError); 170 CheckStrictMode("var x = { 3.14 : 1, 2.71 : 2, 3.14 : 3 };", SyntaxError); 171 CheckStrictMode("var x = { 3.14 : 1, '3.14' : 2 };", SyntaxError); 172 CheckStrictMode("var x = { \ 173 123: 1, \ 174 123.00000000000000000000000000000000000000000000000000000000000000000001: 2 \ 175 }", SyntaxError); 176 177 // Non-conflicting data properties. 178 (function StrictModeNonDuplicate() { 179 "use strict"; 180 var x = { 123 : 1, "0123" : 2 }; 181 var x = { 182 123: 1, 183 '123.00000000000000000000000000000000000000000000000000000000000000000001': 184 2 185 }; 186 })(); 187 188 // Two getters (non-strict) 189 assertThrows("var x = { get foo() { }, get foo() { } };", SyntaxError); 190 assertThrows("var x = { get foo(){}, get 'foo'(){}};", SyntaxError); 191 assertThrows("var x = { get 12(){}, get '12'(){}};", SyntaxError); 192 193 // Two setters (non-strict) 194 assertThrows("var x = { set foo(v) { }, set foo(v) { } };", SyntaxError); 195 assertThrows("var x = { set foo(v) { }, set 'foo'(v) { } };", SyntaxError); 196 assertThrows("var x = { set 13(v) { }, set '13'(v) { } };", SyntaxError); 197 198 // Setter and data (non-strict) 199 assertThrows("var x = { foo: 'data', set foo(v) { } };", SyntaxError); 200 assertThrows("var x = { set foo(v) { }, foo: 'data' };", SyntaxError); 201 assertThrows("var x = { foo: 'data', set 'foo'(v) { } };", SyntaxError); 202 assertThrows("var x = { set foo(v) { }, 'foo': 'data' };", SyntaxError); 203 assertThrows("var x = { 'foo': 'data', set foo(v) { } };", SyntaxError); 204 assertThrows("var x = { set 'foo'(v) { }, foo: 'data' };", SyntaxError); 205 assertThrows("var x = { 'foo': 'data', set 'foo'(v) { } };", SyntaxError); 206 assertThrows("var x = { set 'foo'(v) { }, 'foo': 'data' };", SyntaxError); 207 assertThrows("var x = { 12: 1, set '12'(v){}};", SyntaxError); 208 assertThrows("var x = { 12: 1, set 12(v){}};", SyntaxError); 209 assertThrows("var x = { '12': 1, set '12'(v){}};", SyntaxError); 210 assertThrows("var x = { '12': 1, set 12(v){}};", SyntaxError); 211 212 // Getter and data (non-strict) 213 assertThrows("var x = { foo: 'data', get foo() { } };", SyntaxError); 214 assertThrows("var x = { get foo() { }, foo: 'data' };", SyntaxError); 215 assertThrows("var x = { 'foo': 'data', get foo() { } };", SyntaxError); 216 assertThrows("var x = { get 'foo'() { }, 'foo': 'data' };", SyntaxError); 217 assertThrows("var x = { '12': 1, get '12'(){}};", SyntaxError); 218 assertThrows("var x = { '12': 1, get 12(){}};", SyntaxError); 219 220 // Assignment to eval or arguments 221 CheckStrictMode("function strict() { eval = undefined; }", SyntaxError); 222 CheckStrictMode("function strict() { arguments = undefined; }", SyntaxError); 223 CheckStrictMode("function strict() { print(eval = undefined); }", SyntaxError); 224 CheckStrictMode("function strict() { print(arguments = undefined); }", 225 SyntaxError); 226 CheckStrictMode("function strict() { var x = eval = undefined; }", SyntaxError); 227 CheckStrictMode("function strict() { var x = arguments = undefined; }", 228 SyntaxError); 229 230 // Compound assignment to eval or arguments 231 CheckStrictMode("function strict() { eval *= undefined; }", SyntaxError); 232 CheckStrictMode("function strict() { arguments /= undefined; }", SyntaxError); 233 CheckStrictMode("function strict() { print(eval %= undefined); }", SyntaxError); 234 CheckStrictMode("function strict() { print(arguments %= undefined); }", 235 SyntaxError); 236 CheckStrictMode("function strict() { var x = eval += undefined; }", 237 SyntaxError); 238 CheckStrictMode("function strict() { var x = arguments -= undefined; }", 239 SyntaxError); 240 CheckStrictMode("function strict() { eval <<= undefined; }", SyntaxError); 241 CheckStrictMode("function strict() { arguments >>= undefined; }", SyntaxError); 242 CheckStrictMode("function strict() { print(eval >>>= undefined); }", 243 SyntaxError); 244 CheckStrictMode("function strict() { print(arguments &= undefined); }", 245 SyntaxError); 246 CheckStrictMode("function strict() { var x = eval ^= undefined; }", 247 SyntaxError); 248 CheckStrictMode("function strict() { var x = arguments |= undefined; }", 249 SyntaxError); 250 251 // Postfix increment with eval or arguments 252 CheckStrictMode("function strict() { eval++; }", SyntaxError); 253 CheckStrictMode("function strict() { arguments++; }", SyntaxError); 254 CheckStrictMode("function strict() { print(eval++); }", SyntaxError); 255 CheckStrictMode("function strict() { print(arguments++); }", SyntaxError); 256 CheckStrictMode("function strict() { var x = eval++; }", SyntaxError); 257 CheckStrictMode("function strict() { var x = arguments++; }", SyntaxError); 258 259 // Postfix decrement with eval or arguments 260 CheckStrictMode("function strict() { eval--; }", SyntaxError); 261 CheckStrictMode("function strict() { arguments--; }", SyntaxError); 262 CheckStrictMode("function strict() { print(eval--); }", SyntaxError); 263 CheckStrictMode("function strict() { print(arguments--); }", SyntaxError); 264 CheckStrictMode("function strict() { var x = eval--; }", SyntaxError); 265 CheckStrictMode("function strict() { var x = arguments--; }", SyntaxError); 266 267 // Prefix increment with eval or arguments 268 CheckStrictMode("function strict() { ++eval; }", SyntaxError); 269 CheckStrictMode("function strict() { ++arguments; }", SyntaxError); 270 CheckStrictMode("function strict() { print(++eval); }", SyntaxError); 271 CheckStrictMode("function strict() { print(++arguments); }", SyntaxError); 272 CheckStrictMode("function strict() { var x = ++eval; }", SyntaxError); 273 CheckStrictMode("function strict() { var x = ++arguments; }", SyntaxError); 274 275 // Prefix decrement with eval or arguments 276 CheckStrictMode("function strict() { --eval; }", SyntaxError); 277 CheckStrictMode("function strict() { --arguments; }", SyntaxError); 278 CheckStrictMode("function strict() { print(--eval); }", SyntaxError); 279 CheckStrictMode("function strict() { print(--arguments); }", SyntaxError); 280 CheckStrictMode("function strict() { var x = --eval; }", SyntaxError); 281 CheckStrictMode("function strict() { var x = --arguments; }", SyntaxError); 282 283 // Use of const in strict mode is disallowed in anticipation of ES Harmony. 284 CheckStrictMode("const x = 0;", SyntaxError); 285 CheckStrictMode("for (const x = 0; false;) {}", SyntaxError); 286 CheckStrictMode("function strict() { const x = 0; }", SyntaxError); 287 288 // Strict mode only allows functions in SourceElements 289 CheckStrictMode("if (true) { function invalid() {} }", SyntaxError); 290 CheckStrictMode("for (;false;) { function invalid() {} }", SyntaxError); 291 CheckStrictMode("{ function invalid() {} }", SyntaxError); 292 CheckStrictMode("try { function invalid() {} } catch(e) {}", SyntaxError); 293 CheckStrictMode("try { } catch(e) { function invalid() {} }", SyntaxError); 294 CheckStrictMode("function outer() {{ function invalid() {} }}", SyntaxError); 295 296 // Delete of an unqualified identifier 297 CheckStrictMode("delete unqualified;", SyntaxError); 298 CheckStrictMode("function strict() { delete unqualified; }", SyntaxError); 299 CheckStrictMode("function function_name() { delete function_name; }", 300 SyntaxError); 301 CheckStrictMode("function strict(parameter) { delete parameter; }", 302 SyntaxError); 303 CheckStrictMode("function strict() { var variable; delete variable; }", 304 SyntaxError); 305 CheckStrictMode("var variable; delete variable;", SyntaxError); 306 307 (function TestStrictDelete() { 308 "use strict"; 309 // "delete this" is allowed in strict mode and should work. 310 function strict_delete() { delete this; } 311 strict_delete(); 312 })(); 313 314 // Prefix unary operators other than delete, ++, -- are valid in strict mode 315 (function StrictModeUnaryOperators() { 316 "use strict"; 317 var x = [void eval, typeof eval, +eval, -eval, ~eval, !eval]; 318 var y = [void arguments, typeof arguments, 319 +arguments, -arguments, ~arguments, !arguments]; 320 })(); 321 322 // 7.6.1.2 Future Reserved Words 323 var future_reserved_words = [ 324 "class", 325 "enum", 326 "export", 327 "extends", 328 "import", 329 "super", 330 "implements", 331 "interface", 332 "let", 333 "package", 334 "private", 335 "protected", 336 "public", 337 "static", 338 "yield" ]; 339 340 function testFutureReservedWord(word) { 341 // Simple use of each reserved word 342 CheckStrictMode("var " + word + " = 1;", SyntaxError); 343 344 // object literal properties 345 eval("var x = { " + word + " : 42 };"); 346 eval("var x = { get " + word + " () {} };"); 347 eval("var x = { set " + word + " (value) {} };"); 348 349 // object literal with string literal property names 350 eval("var x = { '" + word + "' : 42 };"); 351 eval("var x = { get '" + word + "' () { } };"); 352 eval("var x = { set '" + word + "' (value) { } };"); 353 eval("var x = { get '" + word + "' () { 'use strict'; } };"); 354 eval("var x = { set '" + word + "' (value) { 'use strict'; } };"); 355 356 // Function names and arguments, strict and non-strict contexts 357 CheckStrictMode("function " + word + " () {}", SyntaxError); 358 CheckStrictMode("function foo (" + word + ") {}", SyntaxError); 359 CheckStrictMode("function foo (" + word + ", " + word + ") {}", SyntaxError); 360 CheckStrictMode("function foo (a, " + word + ") {}", SyntaxError); 361 CheckStrictMode("function foo (" + word + ", a) {}", SyntaxError); 362 CheckStrictMode("function foo (a, " + word + ", b) {}", SyntaxError); 363 CheckStrictMode("var foo = function (" + word + ") {}", SyntaxError); 364 365 // Function names and arguments when the body is strict 366 assertThrows("function " + word + " () { 'use strict'; }", SyntaxError); 367 assertThrows("function foo (" + word + ") 'use strict'; {}", SyntaxError); 368 assertThrows("function foo (" + word + ", " + word + ") { 'use strict'; }", 369 SyntaxError); 370 assertThrows("function foo (a, " + word + ") { 'use strict'; }", SyntaxError); 371 assertThrows("function foo (" + word + ", a) { 'use strict'; }", SyntaxError); 372 assertThrows("function foo (a, " + word + ", b) { 'use strict'; }", 373 SyntaxError); 374 assertThrows("var foo = function (" + word + ") { 'use strict'; }", 375 SyntaxError); 376 377 // get/set when the body is strict 378 eval("var x = { get " + word + " () { 'use strict'; } };"); 379 eval("var x = { set " + word + " (value) { 'use strict'; } };"); 380 assertThrows("var x = { get foo(" + word + ") { 'use strict'; } };", 381 SyntaxError); 382 assertThrows("var x = { set foo(" + word + ") { 'use strict'; } };", 383 SyntaxError); 384 } 385 386 for (var i = 0; i < future_reserved_words.length; i++) { 387 testFutureReservedWord(future_reserved_words[i]); 388 } 389 390 function testAssignToUndefined(test, should_throw) { 391 try { 392 test(); 393 } catch (e) { 394 assertTrue(should_throw, "strict mode"); 395 assertInstanceof(e, ReferenceError, "strict mode"); 396 return; 397 } 398 assertFalse(should_throw, "strict mode"); 399 } 400 401 function repeat(n, f) { 402 for (var i = 0; i < n; i ++) { f(); } 403 } 404 405 function assignToUndefined() { 406 "use strict"; 407 possibly_undefined_variable_for_strict_mode_test = "should throw?"; 408 } 409 410 testAssignToUndefined(assignToUndefined, true); 411 testAssignToUndefined(assignToUndefined, true); 412 testAssignToUndefined(assignToUndefined, true); 413 414 possibly_undefined_variable_for_strict_mode_test = "value"; 415 416 testAssignToUndefined(assignToUndefined, false); 417 testAssignToUndefined(assignToUndefined, false); 418 testAssignToUndefined(assignToUndefined, false); 419 420 delete possibly_undefined_variable_for_strict_mode_test; 421 422 testAssignToUndefined(assignToUndefined, true); 423 testAssignToUndefined(assignToUndefined, true); 424 testAssignToUndefined(assignToUndefined, true); 425 426 repeat(10, function() { testAssignToUndefined(assignToUndefined, true); }); 427 possibly_undefined_variable_for_strict_mode_test = "value"; 428 repeat(10, function() { testAssignToUndefined(assignToUndefined, false); }); 429 delete possibly_undefined_variable_for_strict_mode_test; 430 repeat(10, function() { testAssignToUndefined(assignToUndefined, true); }); 431 possibly_undefined_variable_for_strict_mode_test = undefined; 432 repeat(10, function() { testAssignToUndefined(assignToUndefined, false); }); 433 434 function assignToUndefinedWithEval() { 435 "use strict"; 436 possibly_undefined_variable_for_strict_mode_test_with_eval = "should throw?"; 437 eval(""); 438 } 439 440 testAssignToUndefined(assignToUndefinedWithEval, true); 441 testAssignToUndefined(assignToUndefinedWithEval, true); 442 testAssignToUndefined(assignToUndefinedWithEval, true); 443 444 possibly_undefined_variable_for_strict_mode_test_with_eval = "value"; 445 446 testAssignToUndefined(assignToUndefinedWithEval, false); 447 testAssignToUndefined(assignToUndefinedWithEval, false); 448 testAssignToUndefined(assignToUndefinedWithEval, false); 449 450 delete possibly_undefined_variable_for_strict_mode_test_with_eval; 451 452 testAssignToUndefined(assignToUndefinedWithEval, true); 453 testAssignToUndefined(assignToUndefinedWithEval, true); 454 testAssignToUndefined(assignToUndefinedWithEval, true); 455 456 repeat(10, function() { 457 testAssignToUndefined(assignToUndefinedWithEval, true); 458 }); 459 possibly_undefined_variable_for_strict_mode_test_with_eval = "value"; 460 repeat(10, function() { 461 testAssignToUndefined(assignToUndefinedWithEval, false); 462 }); 463 delete possibly_undefined_variable_for_strict_mode_test_with_eval; 464 repeat(10, function() { 465 testAssignToUndefined(assignToUndefinedWithEval, true); 466 }); 467 possibly_undefined_variable_for_strict_mode_test_with_eval = undefined; 468 repeat(10, function() { 469 testAssignToUndefined(assignToUndefinedWithEval, false); 470 }); 471 472 473 474 (function testDeleteNonConfigurable() { 475 function delete_property(o) { 476 "use strict"; 477 delete o.property; 478 } 479 function delete_element(o, i) { 480 "use strict"; 481 delete o[i]; 482 } 483 484 var object = {}; 485 486 Object.defineProperty(object, "property", { value: "property_value" }); 487 Object.defineProperty(object, "1", { value: "one" }); 488 Object.defineProperty(object, 7, { value: "seven" }); 489 Object.defineProperty(object, 3.14, { value: "pi" }); 490 491 assertThrows(function() { delete_property(object); }, TypeError); 492 assertEquals(object.property, "property_value"); 493 assertThrows(function() { delete_element(object, "1"); }, TypeError); 494 assertThrows(function() { delete_element(object, 1); }, TypeError); 495 assertEquals(object[1], "one"); 496 assertThrows(function() { delete_element(object, "7"); }, TypeError); 497 assertThrows(function() { delete_element(object, 7); }, TypeError); 498 assertEquals(object[7], "seven"); 499 assertThrows(function() { delete_element(object, "3.14"); }, TypeError); 500 assertThrows(function() { delete_element(object, 3.14); }, TypeError); 501 assertEquals(object[3.14], "pi"); 502 })(); 503 504 // Not transforming this in Function.call and Function.apply. 505 (function testThisTransformCallApply() { 506 function non_strict() { 507 return this; 508 } 509 function strict() { 510 "use strict"; 511 return this; 512 } 513 514 var global_object = (function() { return this; })(); 515 var object = {}; 516 517 // Non-strict call. 518 assertTrue(non_strict.call(null) === global_object); 519 assertTrue(non_strict.call(undefined) === global_object); 520 assertEquals(typeof non_strict.call(7), "object"); 521 assertEquals(typeof non_strict.call("Hello"), "object"); 522 assertTrue(non_strict.call(object) === object); 523 524 // Non-strict apply. 525 assertTrue(non_strict.apply(null) === global_object); 526 assertTrue(non_strict.apply(undefined) === global_object); 527 assertEquals(typeof non_strict.apply(7), "object"); 528 assertEquals(typeof non_strict.apply("Hello"), "object"); 529 assertTrue(non_strict.apply(object) === object); 530 531 // Strict call. 532 assertTrue(strict.call(null) === null); 533 assertTrue(strict.call(undefined) === undefined); 534 assertEquals(typeof strict.call(7), "number"); 535 assertEquals(typeof strict.call("Hello"), "string"); 536 assertTrue(strict.call(object) === object); 537 538 // Strict apply. 539 assertTrue(strict.apply(null) === null); 540 assertTrue(strict.apply(undefined) === undefined); 541 assertEquals(typeof strict.apply(7), "number"); 542 assertEquals(typeof strict.apply("Hello"), "string"); 543 assertTrue(strict.apply(object) === object); 544 })(); 545 546 (function testThisTransform() { 547 try { 548 function strict() { 549 "use strict"; 550 return typeof(this); 551 } 552 function nonstrict() { 553 return typeof(this); 554 } 555 556 // Concat to avoid symbol. 557 var strict_name = "str" + "ict"; 558 var nonstrict_name = "non" + "str" + "ict"; 559 var strict_number = 17; 560 var nonstrict_number = 19; 561 var strict_name_get = "str" + "ict" + "get"; 562 var nonstrict_name_get = "non" + "str" + "ict" + "get" 563 var strict_number_get = 23; 564 var nonstrict_number_get = 29; 565 566 function install(t) { 567 t.prototype.strict = strict; 568 t.prototype.nonstrict = nonstrict; 569 t.prototype[strict_number] = strict; 570 t.prototype[nonstrict_number] = nonstrict; 571 Object.defineProperty(t.prototype, strict_name_get, 572 { get: function() { return strict; }, 573 configurable: true }); 574 Object.defineProperty(t.prototype, nonstrict_name_get, 575 { get: function() { return nonstrict; }, 576 configurable: true }); 577 Object.defineProperty(t.prototype, strict_number_get, 578 { get: function() { return strict; }, 579 configurable: true }); 580 Object.defineProperty(t.prototype, nonstrict_number_get, 581 { get: function() { return nonstrict; }, 582 configurable: true }); 583 } 584 585 function cleanup(t) { 586 delete t.prototype.strict; 587 delete t.prototype.nonstrict; 588 delete t.prototype[strict_number]; 589 delete t.prototype[nonstrict_number]; 590 delete t.prototype[strict_name_get]; 591 delete t.prototype[nonstrict_name_get]; 592 delete t.prototype[strict_number_get]; 593 delete t.prototype[nonstrict_number_get]; 594 } 595 596 // Set up fakes 597 install(String); 598 install(Number); 599 install(Boolean) 600 601 function callStrict(o) { 602 return o.strict(); 603 } 604 function callNonStrict(o) { 605 return o.nonstrict(); 606 } 607 function callKeyedStrict(o) { 608 return o[strict_name](); 609 } 610 function callKeyedNonStrict(o) { 611 return o[nonstrict_name](); 612 } 613 function callIndexedStrict(o) { 614 return o[strict_number](); 615 } 616 function callIndexedNonStrict(o) { 617 return o[nonstrict_number](); 618 } 619 function callStrictGet(o) { 620 return o.strictget(); 621 } 622 function callNonStrictGet(o) { 623 return o.nonstrictget(); 624 } 625 function callKeyedStrictGet(o) { 626 return o[strict_name_get](); 627 } 628 function callKeyedNonStrictGet(o) { 629 return o[nonstrict_name_get](); 630 } 631 function callIndexedStrictGet(o) { 632 return o[strict_number_get](); 633 } 634 function callIndexedNonStrictGet(o) { 635 return o[nonstrict_number_get](); 636 } 637 638 for (var i = 0; i < 10; i ++) { 639 assertEquals(("hello").strict(), "string"); 640 assertEquals(("hello").nonstrict(), "object"); 641 assertEquals(("hello")[strict_name](), "string"); 642 assertEquals(("hello")[nonstrict_name](), "object"); 643 assertEquals(("hello")[strict_number](), "string"); 644 assertEquals(("hello")[nonstrict_number](), "object"); 645 646 assertEquals((10 + i).strict(), "number"); 647 assertEquals((10 + i).nonstrict(), "object"); 648 assertEquals((10 + i)[strict_name](), "number"); 649 assertEquals((10 + i)[nonstrict_name](), "object"); 650 assertEquals((10 + i)[strict_number](), "number"); 651 assertEquals((10 + i)[nonstrict_number](), "object"); 652 653 assertEquals((true).strict(), "boolean"); 654 assertEquals((true).nonstrict(), "object"); 655 assertEquals((true)[strict_name](), "boolean"); 656 assertEquals((true)[nonstrict_name](), "object"); 657 assertEquals((true)[strict_number](), "boolean"); 658 assertEquals((true)[nonstrict_number](), "object"); 659 660 assertEquals((false).strict(), "boolean"); 661 assertEquals((false).nonstrict(), "object"); 662 assertEquals((false)[strict_name](), "boolean"); 663 assertEquals((false)[nonstrict_name](), "object"); 664 assertEquals((false)[strict_number](), "boolean"); 665 assertEquals((false)[nonstrict_number](), "object"); 666 667 assertEquals(callStrict("howdy"), "string"); 668 assertEquals(callNonStrict("howdy"), "object"); 669 assertEquals(callKeyedStrict("howdy"), "string"); 670 assertEquals(callKeyedNonStrict("howdy"), "object"); 671 assertEquals(callIndexedStrict("howdy"), "string"); 672 assertEquals(callIndexedNonStrict("howdy"), "object"); 673 674 assertEquals(callStrict(17 + i), "number"); 675 assertEquals(callNonStrict(17 + i), "object"); 676 assertEquals(callKeyedStrict(17 + i), "number"); 677 assertEquals(callKeyedNonStrict(17 + i), "object"); 678 assertEquals(callIndexedStrict(17 + i), "number"); 679 assertEquals(callIndexedNonStrict(17 + i), "object"); 680 681 assertEquals(callStrict(true), "boolean"); 682 assertEquals(callNonStrict(true), "object"); 683 assertEquals(callKeyedStrict(true), "boolean"); 684 assertEquals(callKeyedNonStrict(true), "object"); 685 assertEquals(callIndexedStrict(true), "boolean"); 686 assertEquals(callIndexedNonStrict(true), "object"); 687 688 assertEquals(callStrict(false), "boolean"); 689 assertEquals(callNonStrict(false), "object"); 690 assertEquals(callKeyedStrict(false), "boolean"); 691 assertEquals(callKeyedNonStrict(false), "object"); 692 assertEquals(callIndexedStrict(false), "boolean"); 693 assertEquals(callIndexedNonStrict(false), "object"); 694 695 // All of the above, with getters 696 assertEquals(("hello").strictget(), "string"); 697 assertEquals(("hello").nonstrictget(), "object"); 698 assertEquals(("hello")[strict_name_get](), "string"); 699 assertEquals(("hello")[nonstrict_name_get](), "object"); 700 assertEquals(("hello")[strict_number_get](), "string"); 701 assertEquals(("hello")[nonstrict_number_get](), "object"); 702 703 assertEquals((10 + i).strictget(), "number"); 704 assertEquals((10 + i).nonstrictget(), "object"); 705 assertEquals((10 + i)[strict_name_get](), "number"); 706 assertEquals((10 + i)[nonstrict_name_get](), "object"); 707 assertEquals((10 + i)[strict_number_get](), "number"); 708 assertEquals((10 + i)[nonstrict_number_get](), "object"); 709 710 assertEquals((true).strictget(), "boolean"); 711 assertEquals((true).nonstrictget(), "object"); 712 assertEquals((true)[strict_name_get](), "boolean"); 713 assertEquals((true)[nonstrict_name_get](), "object"); 714 assertEquals((true)[strict_number_get](), "boolean"); 715 assertEquals((true)[nonstrict_number_get](), "object"); 716 717 assertEquals((false).strictget(), "boolean"); 718 assertEquals((false).nonstrictget(), "object"); 719 assertEquals((false)[strict_name_get](), "boolean"); 720 assertEquals((false)[nonstrict_name_get](), "object"); 721 assertEquals((false)[strict_number_get](), "boolean"); 722 assertEquals((false)[nonstrict_number_get](), "object"); 723 724 assertEquals(callStrictGet("howdy"), "string"); 725 assertEquals(callNonStrictGet("howdy"), "object"); 726 assertEquals(callKeyedStrictGet("howdy"), "string"); 727 assertEquals(callKeyedNonStrictGet("howdy"), "object"); 728 assertEquals(callIndexedStrictGet("howdy"), "string"); 729 assertEquals(callIndexedNonStrictGet("howdy"), "object"); 730 731 assertEquals(callStrictGet(17 + i), "number"); 732 assertEquals(callNonStrictGet(17 + i), "object"); 733 assertEquals(callKeyedStrictGet(17 + i), "number"); 734 assertEquals(callKeyedNonStrictGet(17 + i), "object"); 735 assertEquals(callIndexedStrictGet(17 + i), "number"); 736 assertEquals(callIndexedNonStrictGet(17 + i), "object"); 737 738 assertEquals(callStrictGet(true), "boolean"); 739 assertEquals(callNonStrictGet(true), "object"); 740 assertEquals(callKeyedStrictGet(true), "boolean"); 741 assertEquals(callKeyedNonStrictGet(true), "object"); 742 assertEquals(callIndexedStrictGet(true), "boolean"); 743 assertEquals(callIndexedNonStrictGet(true), "object"); 744 745 assertEquals(callStrictGet(false), "boolean"); 746 assertEquals(callNonStrictGet(false), "object"); 747 assertEquals(callKeyedStrictGet(false), "boolean"); 748 assertEquals(callKeyedNonStrictGet(false), "object"); 749 assertEquals(callIndexedStrictGet(false), "boolean"); 750 assertEquals(callIndexedNonStrictGet(false), "object"); 751 752 } 753 } finally { 754 // Cleanup 755 cleanup(String); 756 cleanup(Number); 757 cleanup(Boolean); 758 } 759 })(); 760 761 762 (function ObjectEnvironment() { 763 var o = {}; 764 Object.defineProperty(o, "foo", { value: "FOO", writable: false }); 765 assertThrows( 766 function () { 767 with (o) { 768 (function() { 769 "use strict"; 770 foo = "Hello"; 771 })(); 772 } 773 }, 774 TypeError); 775 })(); 776 777 778 (function TestSetPropertyWithoutSetter() { 779 var o = { get foo() { return "Yey"; } }; 780 assertThrows( 781 function broken() { 782 "use strict"; 783 o.foo = (0xBADBAD00 >> 1); 784 }, 785 TypeError); 786 })(); 787 788 789 (function TestSetPropertyNonConfigurable() { 790 var frozen = Object.freeze({}); 791 var sealed = Object.seal({}); 792 793 function strict(o) { 794 "use strict"; 795 o.property = "value"; 796 } 797 798 assertThrows(function() { strict(frozen); }, TypeError); 799 assertThrows(function() { strict(sealed); }, TypeError); 800 })(); 801 802 803 (function TestAssignmentToReadOnlyProperty() { 804 "use strict"; 805 806 var o = {}; 807 Object.defineProperty(o, "property", { value: 7 }); 808 809 assertThrows(function() { o.property = "new value"; }, TypeError); 810 assertThrows(function() { o.property += 10; }, TypeError); 811 assertThrows(function() { o.property -= 10; }, TypeError); 812 assertThrows(function() { o.property *= 10; }, TypeError); 813 assertThrows(function() { o.property /= 10; }, TypeError); 814 assertThrows(function() { o.property++; }, TypeError); 815 assertThrows(function() { o.property--; }, TypeError); 816 assertThrows(function() { ++o.property; }, TypeError); 817 assertThrows(function() { --o.property; }, TypeError); 818 819 var name = "prop" + "erty"; // to avoid symbol path. 820 assertThrows(function() { o[name] = "new value"; }, TypeError); 821 assertThrows(function() { o[name] += 10; }, TypeError); 822 assertThrows(function() { o[name] -= 10; }, TypeError); 823 assertThrows(function() { o[name] *= 10; }, TypeError); 824 assertThrows(function() { o[name] /= 10; }, TypeError); 825 assertThrows(function() { o[name]++; }, TypeError); 826 assertThrows(function() { o[name]--; }, TypeError); 827 assertThrows(function() { ++o[name]; }, TypeError); 828 assertThrows(function() { --o[name]; }, TypeError); 829 830 assertEquals(o.property, 7); 831 })(); 832 833 834 (function TestAssignmentToReadOnlyLoop() { 835 var name = "prop" + "erty"; // to avoid symbol path. 836 var o = {}; 837 Object.defineProperty(o, "property", { value: 7 }); 838 839 function strict(o, name) { 840 "use strict"; 841 o[name] = "new value"; 842 } 843 844 for (var i = 0; i < 10; i ++) { 845 try { 846 strict(o, name); 847 assertUnreachable(); 848 } catch(e) { 849 assertInstanceof(e, TypeError); 850 } 851 } 852 })(); 853 854 855 // Specialized KeyedStoreIC experiencing miss. 856 (function testKeyedStoreICStrict() { 857 var o = [9,8,7,6,5,4,3,2,1]; 858 859 function test(o, i, v) { 860 "use strict"; 861 o[i] = v; 862 } 863 864 for (var i = 0; i < 10; i ++) { 865 test(o, 5, 17); // start specialized for smi indices 866 assertEquals(o[5], 17); 867 test(o, "a", 19); 868 assertEquals(o["a"], 19); 869 test(o, "5", 29); 870 assertEquals(o[5], 29); 871 test(o, 100000, 31); 872 assertEquals(o[100000], 31); 873 } 874 })(); 875 876 877 (function TestSetElementWithoutSetter() { 878 "use strict"; 879 880 var o = { }; 881 Object.defineProperty(o, 0, { get : function() { } }); 882 883 var zero_smi = 0; 884 var zero_number = new Number(0); 885 var zero_symbol = "0"; 886 var zero_string = "-0-".substring(1,2); 887 888 assertThrows(function() { o[zero_smi] = "new value"; }, TypeError); 889 assertThrows(function() { o[zero_number] = "new value"; }, TypeError); 890 assertThrows(function() { o[zero_symbol] = "new value"; }, TypeError); 891 assertThrows(function() { o[zero_string] = "new value"; }, TypeError); 892 })(); 893 894 895 (function TestSetElementNonConfigurable() { 896 "use strict"; 897 var frozen = Object.freeze({}); 898 var sealed = Object.seal({}); 899 900 var zero_number = 0; 901 var zero_symbol = "0"; 902 var zero_string = "-0-".substring(1,2); 903 904 assertThrows(function() { frozen[zero_number] = "value"; }, TypeError); 905 assertThrows(function() { sealed[zero_number] = "value"; }, TypeError); 906 assertThrows(function() { frozen[zero_symbol] = "value"; }, TypeError); 907 assertThrows(function() { sealed[zero_symbol] = "value"; }, TypeError); 908 assertThrows(function() { frozen[zero_string] = "value"; }, TypeError); 909 assertThrows(function() { sealed[zero_string] = "value"; }, TypeError); 910 })(); 911 912 913 (function TestAssignmentToReadOnlyElement() { 914 "use strict"; 915 916 var o = {}; 917 Object.defineProperty(o, 7, { value: 17 }); 918 919 var seven_smi = 7; 920 var seven_number = new Number(7); 921 var seven_symbol = "7"; 922 var seven_string = "-7-".substring(1,2); 923 924 // Index with number. 925 assertThrows(function() { o[seven_smi] = "value"; }, TypeError); 926 assertThrows(function() { o[seven_smi] += 10; }, TypeError); 927 assertThrows(function() { o[seven_smi] -= 10; }, TypeError); 928 assertThrows(function() { o[seven_smi] *= 10; }, TypeError); 929 assertThrows(function() { o[seven_smi] /= 10; }, TypeError); 930 assertThrows(function() { o[seven_smi]++; }, TypeError); 931 assertThrows(function() { o[seven_smi]--; }, TypeError); 932 assertThrows(function() { ++o[seven_smi]; }, TypeError); 933 assertThrows(function() { --o[seven_smi]; }, TypeError); 934 935 assertThrows(function() { o[seven_number] = "value"; }, TypeError); 936 assertThrows(function() { o[seven_number] += 10; }, TypeError); 937 assertThrows(function() { o[seven_number] -= 10; }, TypeError); 938 assertThrows(function() { o[seven_number] *= 10; }, TypeError); 939 assertThrows(function() { o[seven_number] /= 10; }, TypeError); 940 assertThrows(function() { o[seven_number]++; }, TypeError); 941 assertThrows(function() { o[seven_number]--; }, TypeError); 942 assertThrows(function() { ++o[seven_number]; }, TypeError); 943 assertThrows(function() { --o[seven_number]; }, TypeError); 944 945 assertThrows(function() { o[seven_symbol] = "value"; }, TypeError); 946 assertThrows(function() { o[seven_symbol] += 10; }, TypeError); 947 assertThrows(function() { o[seven_symbol] -= 10; }, TypeError); 948 assertThrows(function() { o[seven_symbol] *= 10; }, TypeError); 949 assertThrows(function() { o[seven_symbol] /= 10; }, TypeError); 950 assertThrows(function() { o[seven_symbol]++; }, TypeError); 951 assertThrows(function() { o[seven_symbol]--; }, TypeError); 952 assertThrows(function() { ++o[seven_symbol]; }, TypeError); 953 assertThrows(function() { --o[seven_symbol]; }, TypeError); 954 955 assertThrows(function() { o[seven_string] = "value"; }, TypeError); 956 assertThrows(function() { o[seven_string] += 10; }, TypeError); 957 assertThrows(function() { o[seven_string] -= 10; }, TypeError); 958 assertThrows(function() { o[seven_string] *= 10; }, TypeError); 959 assertThrows(function() { o[seven_string] /= 10; }, TypeError); 960 assertThrows(function() { o[seven_string]++; }, TypeError); 961 assertThrows(function() { o[seven_string]--; }, TypeError); 962 assertThrows(function() { ++o[seven_string]; }, TypeError); 963 assertThrows(function() { --o[seven_string]; }, TypeError); 964 965 assertEquals(o[seven_number], 17); 966 assertEquals(o[seven_symbol], 17); 967 assertEquals(o[seven_string], 17); 968 })(); 969 970 971 (function TestAssignmentToReadOnlyLoop() { 972 "use strict"; 973 974 var o = {}; 975 Object.defineProperty(o, 7, { value: 17 }); 976 977 var seven_smi = 7; 978 var seven_number = new Number(7); 979 var seven_symbol = "7"; 980 var seven_string = "-7-".substring(1,2); 981 982 for (var i = 0; i < 10; i ++) { 983 assertThrows(function() { o[seven_smi] = "value" }, TypeError); 984 assertThrows(function() { o[seven_number] = "value" }, TypeError); 985 assertThrows(function() { o[seven_symbol] = "value" }, TypeError); 986 assertThrows(function() { o[seven_string] = "value" }, TypeError); 987 } 988 989 assertEquals(o[7], 17); 990 })(); 991 992 993 (function TestAssignmentToStringLength() { 994 "use strict"; 995 996 var str_val = "string"; 997 var str_obj = new String(str_val); 998 var str_cat = str_val + str_val + str_obj; 999 1000 assertThrows(function() { str_val.length = 1; }, TypeError); 1001 assertThrows(function() { str_obj.length = 1; }, TypeError); 1002 assertThrows(function() { str_cat.length = 1; }, TypeError); 1003 })(); 1004 1005 1006 (function TestArgumentsAliasing() { 1007 function strict(a, b) { 1008 "use strict"; 1009 a = "c"; 1010 b = "d"; 1011 return [a, b, arguments[0], arguments[1]]; 1012 } 1013 1014 function nonstrict(a, b) { 1015 a = "c"; 1016 b = "d"; 1017 return [a, b, arguments[0], arguments[1]]; 1018 } 1019 1020 assertEquals(["c", "d", "a", "b"], strict("a", "b")); 1021 assertEquals(["c", "d", "c", "d"], nonstrict("a", "b")); 1022 })(); 1023 1024 1025 function CheckPillDescriptor(func, name) { 1026 1027 function CheckPill(pill) { 1028 assertEquals("function", typeof pill); 1029 assertInstanceof(pill, Function); 1030 pill.property = "value"; 1031 assertEquals(pill.value, undefined); 1032 assertThrows(function() { 'use strict'; pill.property = "value"; }, 1033 TypeError); 1034 assertThrows(pill, TypeError); 1035 assertEquals(pill.prototype, (function(){}).prototype); 1036 var d = Object.getOwnPropertyDescriptor(pill, "prototype"); 1037 assertFalse(d.writable); 1038 assertFalse(d.configurable); 1039 assertFalse(d.enumerable); 1040 } 1041 1042 var descriptor = Object.getOwnPropertyDescriptor(func, name); 1043 CheckPill(descriptor.get) 1044 CheckPill(descriptor.set); 1045 assertFalse(descriptor.enumerable); 1046 assertFalse(descriptor.configurable); 1047 } 1048 1049 1050 (function TestStrictFunctionPills() { 1051 function strict() { 1052 "use strict"; 1053 } 1054 assertThrows(function() { strict.caller; }, TypeError); 1055 assertThrows(function() { strict.arguments; }, TypeError); 1056 1057 var another = new Function("'use strict'"); 1058 assertThrows(function() { another.caller; }, TypeError); 1059 assertThrows(function() { another.arguments; }, TypeError); 1060 1061 var third = (function() { "use strict"; return function() {}; })(); 1062 assertThrows(function() { third.caller; }, TypeError); 1063 assertThrows(function() { third.arguments; }, TypeError); 1064 1065 CheckPillDescriptor(strict, "caller"); 1066 CheckPillDescriptor(strict, "arguments"); 1067 CheckPillDescriptor(another, "caller"); 1068 CheckPillDescriptor(another, "arguments"); 1069 CheckPillDescriptor(third, "caller"); 1070 CheckPillDescriptor(third, "arguments"); 1071 })(); 1072 1073 1074 (function TestStrictFunctionWritablePrototype() { 1075 "use strict"; 1076 function TheClass() { 1077 } 1078 assertThrows(function() { TheClass.caller; }, TypeError); 1079 assertThrows(function() { TheClass.arguments; }, TypeError); 1080 1081 // Strict functions must have writable prototype. 1082 TheClass.prototype = { 1083 func: function() { return "func_value"; }, 1084 get accessor() { return "accessor_value"; }, 1085 property: "property_value", 1086 }; 1087 1088 var o = new TheClass(); 1089 assertEquals(o.func(), "func_value"); 1090 assertEquals(o.accessor, "accessor_value"); 1091 assertEquals(o.property, "property_value"); 1092 })(); 1093 1094 1095 (function TestStrictArgumentPills() { 1096 function strict() { 1097 "use strict"; 1098 return arguments; 1099 } 1100 1101 var args = strict(); 1102 CheckPillDescriptor(args, "caller"); 1103 CheckPillDescriptor(args, "callee"); 1104 1105 args = strict(17, "value", strict); 1106 assertEquals(17, args[0]) 1107 assertEquals("value", args[1]) 1108 assertEquals(strict, args[2]); 1109 CheckPillDescriptor(args, "caller"); 1110 CheckPillDescriptor(args, "callee"); 1111 1112 function outer() { 1113 "use strict"; 1114 function inner() { 1115 return arguments; 1116 } 1117 return inner; 1118 } 1119 1120 var args = outer()(); 1121 CheckPillDescriptor(args, "caller"); 1122 CheckPillDescriptor(args, "callee"); 1123 1124 args = outer()(17, "value", strict); 1125 assertEquals(17, args[0]) 1126 assertEquals("value", args[1]) 1127 assertEquals(strict, args[2]); 1128 CheckPillDescriptor(args, "caller"); 1129 CheckPillDescriptor(args, "callee"); 1130 })(); 1131 1132 1133 (function TestNonStrictFunctionCallerPillSimple() { 1134 function return_my_caller() { 1135 return return_my_caller.caller; 1136 } 1137 1138 function strict() { 1139 "use strict"; 1140 return_my_caller(); 1141 } 1142 assertThrows(strict, TypeError); 1143 1144 function non_strict() { 1145 return return_my_caller(); 1146 } 1147 assertSame(non_strict(), non_strict); 1148 })(); 1149 1150 1151 (function TestNonStrictFunctionCallerPill() { 1152 function strict(n) { 1153 "use strict"; 1154 non_strict(n); 1155 } 1156 1157 function recurse(n, then) { 1158 if (n > 0) { 1159 recurse(n - 1); 1160 } else { 1161 return then(); 1162 } 1163 } 1164 1165 function non_strict(n) { 1166 recurse(n, function() { non_strict.caller; }); 1167 } 1168 1169 function test(n) { 1170 try { 1171 recurse(n, function() { strict(n); }); 1172 } catch(e) { 1173 return e instanceof TypeError; 1174 } 1175 return false; 1176 } 1177 1178 for (var i = 0; i < 10; i ++) { 1179 assertEquals(test(i), true); 1180 } 1181 })(); 1182
