blob: 338f6d10f5061f3b685ce4eec2492e9b58ad1aec [file] [log] [blame]
// Copyright 2011 the V8 project authors. All rights reserved.
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following
// disclaimer in the documentation and/or other materials provided
// with the distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived
// from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// Flags: --allow-natives-syntax
var y = 3;
function get_y() { return this.y; }
function strict_get_y() { "use strict"; return this.y; }
// Test calls to strict mode function as methods.
for (var i = 0; i < 10; i++) assertEquals(3, strict_get_y.call(this));
var o = { y: 42 };
for (var i = 0; i < 10; i++) assertEquals(42, strict_get_y.call(o));
// Test calls to strict mode function with implicit receiver.
function g() {
var exception = false;
try { strict_get_y(); } catch(e) { exception = true; }
assertTrue(exception);
}
for (var i = 0; i < 3; i++) g();
// Test calls to local strict mode function with implicit receiver.
function local_function_test() {
function get_y() { return this.y; }
function strict_get_y() { "use strict"; return this.y; }
assertEquals(3, get_y());
assertEquals(3, get_y(23));
var exception = false;
try {
strict_get_y();
} catch(e) {
exception = true;
}
assertTrue(exception);
}
for (var i = 0; i < 10; i++) {
local_function_test();
}
// Test call to catch variable strict-mode function. Implicit
// receiver.
var exception = false;
try {
throw strict_get_y;
} catch(f) {
try {
f();
} catch(e) {
exception = true;
}
assertTrue(exception);
}
// Test calls to strict-mode function with the object from a with
// statement as the receiver.
with(this) {
assertEquals(3, strict_get_y());
assertEquals(3, strict_get_y(32));
}
var o = { y: 27 };
o.f = strict_get_y;
with(o) {
assertEquals(27, f());
assertEquals(27, f(23));
}
// Check calls to eval within a function with 'undefined' as receiver.
function implicit_receiver_eval() {
"use strict";
return eval("this");
}
assertEquals(void 0, implicit_receiver_eval());
assertEquals(void 0, implicit_receiver_eval(32));
// Strict mode function to get inlined.
function strict_return_receiver() {
"use strict";
return this;
}
// Inline with implicit receiver.
function g() {
return strict_return_receiver();
}
for (var i = 0; i < 5; i++) {
assertEquals(void 0, g());
assertEquals(void 0, g(42));
}
%OptimizeFunctionOnNextCall(g);
assertEquals(void 0, g(42));
assertEquals(void 0, g());
// Inline with explicit receiver.
function g2() {
var o = {};
o.f = strict_return_receiver;
return o.f();
}
for (var i = 0; i < 5; i++) {
assertTrue(typeof g2() == "object");
assertTrue(typeof g2(42) == "object");
}
%OptimizeFunctionOnNextCall(g2);
assertTrue(typeof g2() == "object");
assertTrue(typeof g2(42) == "object");
// Test calls of aliased eval.
function outer_eval_receiver() {
var eval = function() { return this; }
function inner_strict() {
"use strict";
assertEquals('object', typeof eval());
}
inner_strict();
}
outer_eval_receiver();
function outer_eval_conversion3(eval, expected) {
function inner_strict() {
"use strict";
var x = eval("this");
assertEquals(expected, typeof x);
}
inner_strict();
}
function strict_return_this() { "use strict"; return this; }
function return_this() { return this; }
function strict_eval(s) { "use strict"; return eval(s); }
function non_strict_eval(s) { return eval(s); }
outer_eval_conversion3(strict_return_this, 'undefined');
outer_eval_conversion3(return_this, 'object');
outer_eval_conversion3(strict_eval, 'undefined');
outer_eval_conversion3(non_strict_eval, 'object');
// TODO(ager): I'm not sure this is in accordance with the spec. At
// the moment, any call to eval where eval is not bound in the global
// context is treated as an indirect call to eval which means that the
// global context is used and the global object is passed as the
// receiver.
outer_eval_conversion3(eval, 'object');
function test_constant_function() {
var o = { f: function() { "use strict"; return this; } };
this.__proto__ = o;
for (var i = 0; i < 10; i++) assertEquals(void 0, f());
}
test_constant_function();
function test_field() {
var o = { };
o.f = function() {};
o.f = function() { "use strict"; return this; };
this.__proto__ = o;
for (var i = 0; i < 10; i++) assertEquals(void 0, f());
}
test_field();