diff options
Diffstat (limited to 'js/src/jit-test/tests/arrow-functions')
47 files changed, 437 insertions, 0 deletions
diff --git a/js/src/jit-test/tests/arrow-functions/arguments-1.js b/js/src/jit-test/tests/arrow-functions/arguments-1.js new file mode 100644 index 000000000..1bd8bc0cd --- /dev/null +++ b/js/src/jit-test/tests/arrow-functions/arguments-1.js @@ -0,0 +1,5 @@ +// no 'arguments' binding in arrow functions + +var arguments = []; +var f = () => arguments; +assertEq(f(), arguments); diff --git a/js/src/jit-test/tests/arrow-functions/arguments-2.js b/js/src/jit-test/tests/arrow-functions/arguments-2.js new file mode 100644 index 000000000..d6ad23ce8 --- /dev/null +++ b/js/src/jit-test/tests/arrow-functions/arguments-2.js @@ -0,0 +1,9 @@ +// 'arguments' is lexically scoped in arrow functions + +var args, g; +function f() { + g = () => arguments; + args = arguments; +} +f(); +assertEq(g(), args); diff --git a/js/src/jit-test/tests/arrow-functions/arguments-3.js b/js/src/jit-test/tests/arrow-functions/arguments-3.js new file mode 100644 index 000000000..f4453438c --- /dev/null +++ b/js/src/jit-test/tests/arrow-functions/arguments-3.js @@ -0,0 +1,16 @@ +// 'arguments' in eval + +function f() { + var g = s => eval(s); + assertEq(g("arguments"), arguments); +} + +f(); +f(0, 1, 2); + +function h() { + return s => eval(s); +} +var result = h(1, 2, 3, 4)("arguments"); +assertEq(result.length, 4); +assertEq(result[3], 4); diff --git a/js/src/jit-test/tests/arrow-functions/arguments-4.js b/js/src/jit-test/tests/arrow-functions/arguments-4.js new file mode 100644 index 000000000..8a28cee06 --- /dev/null +++ b/js/src/jit-test/tests/arrow-functions/arguments-4.js @@ -0,0 +1,22 @@ +load(libdir + "asserts.js"); + +// 'arguments' is allowed in a non-arrow-function with a rest param. +assertEq((function(...rest) { return (x => arguments)(1, 2)})().length, 0); + +function restAndArgs(...rest) { + return () => eval("arguments"); +} + +var args = restAndArgs(1, 2, 3)(); +assertEq(args.length, 3); +assertEq(args[0], 1); +assertEq(args[1], 2); +assertEq(args[2], 3); + +(function() { + return ((...rest) => { + assertDeepEq(rest, [1, 2, 3]); + assertEq(arguments.length, 2); + assertEq(eval("arguments").length, 2); + })(1, 2, 3); +})(4, 5); diff --git a/js/src/jit-test/tests/arrow-functions/associativity-1.js b/js/src/jit-test/tests/arrow-functions/associativity-1.js new file mode 100644 index 000000000..a3ce3ea34 --- /dev/null +++ b/js/src/jit-test/tests/arrow-functions/associativity-1.js @@ -0,0 +1,8 @@ +// Arrow right-associativity. + +var t = a => b => a; +assertEq(t('A')('B'), 'A'); + +var curry = f => a => b => f(a, b); +var curried_atan2 = curry(Math.atan2); +assertEq(curried_atan2(0)(1), 0); diff --git a/js/src/jit-test/tests/arrow-functions/associativity-2.js b/js/src/jit-test/tests/arrow-functions/associativity-2.js new file mode 100644 index 000000000..45712965f --- /dev/null +++ b/js/src/jit-test/tests/arrow-functions/associativity-2.js @@ -0,0 +1,8 @@ +// Arrow right-associativity with = + +var a, b, c; +a = b = c => a = b = c; +assertEq(a, b); +a(13); +assertEq(b, 13); +assertEq(a, 13); diff --git a/js/src/jit-test/tests/arrow-functions/associativity-3.js b/js/src/jit-test/tests/arrow-functions/associativity-3.js new file mode 100644 index 000000000..2be671c5b --- /dev/null +++ b/js/src/jit-test/tests/arrow-functions/associativity-3.js @@ -0,0 +1,5 @@ +// Arrow right-associativity with += + +var s = ""; +s += x => x.name; +assertEq(s, "x => x.name"); diff --git a/js/src/jit-test/tests/arrow-functions/block-1.js b/js/src/jit-test/tests/arrow-functions/block-1.js new file mode 100644 index 000000000..7bfdf43a6 --- /dev/null +++ b/js/src/jit-test/tests/arrow-functions/block-1.js @@ -0,0 +1,6 @@ +// Braces after => indicate a block body as opposed to an expression body. + +var f = () => {}; +assertEq(f(), undefined); +var g = () => ({}); +assertEq(typeof g(), 'object'); diff --git a/js/src/jit-test/tests/arrow-functions/block-2.js b/js/src/jit-test/tests/arrow-functions/block-2.js new file mode 100644 index 000000000..66637f53f --- /dev/null +++ b/js/src/jit-test/tests/arrow-functions/block-2.js @@ -0,0 +1,4 @@ +// Block arrow functions don't return the last expression-statement value automatically. + +var f = a => { a + 1; }; +assertEq(f(0), undefined); diff --git a/js/src/jit-test/tests/arrow-functions/bug-885067-1.js b/js/src/jit-test/tests/arrow-functions/bug-885067-1.js new file mode 100644 index 000000000..04ee5fe50 --- /dev/null +++ b/js/src/jit-test/tests/arrow-functions/bug-885067-1.js @@ -0,0 +1,3 @@ +(function() { + a = (b => eval("0; [arguments]"))(); +})(); diff --git a/js/src/jit-test/tests/arrow-functions/bug-885067-2.js b/js/src/jit-test/tests/arrow-functions/bug-885067-2.js new file mode 100644 index 000000000..a45bdccb8 --- /dev/null +++ b/js/src/jit-test/tests/arrow-functions/bug-885067-2.js @@ -0,0 +1,28 @@ +// deoptimize `arguments` in the arrow's closest enclosing non-arrow-function + +// non-arrow-function -> arrow function +a = 0; +(function() { + a = (() => eval("arguments"))(); +})(1, 2, 3, 4); +assertEq(a.length, 4); + +// non-arrow-function -> arrow function -> arrow function +a = 0; +(function() { + (() => { + a = (() => eval("arguments"))(); + })(); +})(1, 2, 3, 4); +assertEq(a.length, 4); + +// non-arrow-function -> arrow function -> non-arrow-function -> arrow function +a = 0; +(function() { + (() => { + (function () { + a = (() => eval("arguments"))(); + })(1, 2, 3, 4); + })(); +})(); +assertEq(a.length, 4); diff --git a/js/src/jit-test/tests/arrow-functions/bug-885219.js b/js/src/jit-test/tests/arrow-functions/bug-885219.js new file mode 100644 index 000000000..70544bde8 --- /dev/null +++ b/js/src/jit-test/tests/arrow-functions/bug-885219.js @@ -0,0 +1,2 @@ +if (typeof disassemble === "function") + disassemble("-r", Function("()=>e,d")); diff --git a/js/src/jit-test/tests/arrow-functions/church-1.js b/js/src/jit-test/tests/arrow-functions/church-1.js new file mode 100644 index 000000000..7849980a5 --- /dev/null +++ b/js/src/jit-test/tests/arrow-functions/church-1.js @@ -0,0 +1,17 @@ +// Church booleans + +var True = t => f => t; +var False = t => f => f; +var bool_to_str = b => b("True")("False"); +var And = a => b => a(b)(a); +var Or = a => b => a(a)(b); + +assertEq(And(True)(True), True); +assertEq(And(True)(False), False); +assertEq(And(False)(True), False); +assertEq(And(False)(False), False); + +assertEq(Or(True)(True), True); +assertEq(Or(True)(False), True); +assertEq(Or(False)(True), True); +assertEq(Or(False)(False), False); diff --git a/js/src/jit-test/tests/arrow-functions/church-2.js b/js/src/jit-test/tests/arrow-functions/church-2.js new file mode 100644 index 000000000..d38be6fdb --- /dev/null +++ b/js/src/jit-test/tests/arrow-functions/church-2.js @@ -0,0 +1,19 @@ +// Church-Peano integers + +var Zero = f => x => x; +var Succ = n => f => x => n(f)(f(x)); +var Add = a => b => f => x => a(f)(b(f)(x)); +var Mul = a => b => f => x => a(b(f))(x); +var Exp = a => b => b(a); + +var n = f => f(k => k + 1)(0); + +assertEq(n(Zero), 0); +assertEq(n(Succ(Zero)), 1); +assertEq(n(Succ(Succ(Zero))), 2); + +var Three = Succ(Succ(Succ(Zero))); +var Five = Succ(Succ(Three)); +assertEq(n(Add(Three)(Five)), 8); +assertEq(n(Mul(Three)(Five)), 15); +assertEq(n(Exp(Three)(Five)), 243); diff --git a/js/src/jit-test/tests/arrow-functions/close-paren-arrow-after-expr.js b/js/src/jit-test/tests/arrow-functions/close-paren-arrow-after-expr.js new file mode 100644 index 000000000..a9ecb7caa --- /dev/null +++ b/js/src/jit-test/tests/arrow-functions/close-paren-arrow-after-expr.js @@ -0,0 +1,8 @@ +var caught = false; +try { + eval("1\n)=>"); +} catch (e) { + assertEq(e instanceof SyntaxError, true); + caught = true; +} +assertEq(caught, true); diff --git a/js/src/jit-test/tests/arrow-functions/column-number.js b/js/src/jit-test/tests/arrow-functions/column-number.js new file mode 100644 index 000000000..e5e34f80a --- /dev/null +++ b/js/src/jit-test/tests/arrow-functions/column-number.js @@ -0,0 +1,6 @@ +function f() { return g(abcd => Error()); } +function g(x) { return x(); } +var err = f(1, 2); +var lines = err.stack.split("\n"); +assertEq(lines[0].endsWith(":1:33"), true); +assertEq(lines[1].endsWith(":2:24"), true); diff --git a/js/src/jit-test/tests/arrow-functions/const-1.js b/js/src/jit-test/tests/arrow-functions/const-1.js new file mode 100644 index 000000000..f8e7fce4c --- /dev/null +++ b/js/src/jit-test/tests/arrow-functions/const-1.js @@ -0,0 +1,11 @@ +// Arguments with default parameters can shadow const locals. + +"use strict"; + +function f() { + const x = 1; + return (x = 0) => x; +} + +var g = f(); +assertEq(g(), 0); diff --git a/js/src/jit-test/tests/arrow-functions/construct-1.js b/js/src/jit-test/tests/arrow-functions/construct-1.js new file mode 100644 index 000000000..0871888e3 --- /dev/null +++ b/js/src/jit-test/tests/arrow-functions/construct-1.js @@ -0,0 +1,7 @@ +// Arrow functions are not constructors. + +load(libdir + "asserts.js"); + +var f = a => { this.a = a; }; +assertThrowsInstanceOf(() => new f, TypeError); +assertThrowsInstanceOf(() => new f(1, 2), TypeError); diff --git a/js/src/jit-test/tests/arrow-functions/eval-1.js b/js/src/jit-test/tests/arrow-functions/eval-1.js new file mode 100644 index 000000000..fba4de65f --- /dev/null +++ b/js/src/jit-test/tests/arrow-functions/eval-1.js @@ -0,0 +1,9 @@ +// Arrow functions in direct eval code. + +function f(s) { + var a = 2; + return eval(s); +} + +var c = f("k => a + k"); // closure should see 'a' +assertEq(c(3), 5); diff --git a/js/src/jit-test/tests/arrow-functions/length.js b/js/src/jit-test/tests/arrow-functions/length.js new file mode 100644 index 000000000..53ca3e64d --- /dev/null +++ b/js/src/jit-test/tests/arrow-functions/length.js @@ -0,0 +1,11 @@ +// Arrow functions have a .length property like ordinary functions. + +assertEq((a => a).hasOwnProperty("length"), true); + +assertEq((a => a).length, 1); +assertEq((() => 0).length, 0); +assertEq(((a) => 0).length, 1); +assertEq(((a, b) => 0).length, 2); + +assertEq(((...arr) => arr).length, 0); +assertEq(((a=1, b=2) => 0).length, 0); diff --git a/js/src/jit-test/tests/arrow-functions/params-1.js b/js/src/jit-test/tests/arrow-functions/params-1.js new file mode 100644 index 000000000..5c2395c39 --- /dev/null +++ b/js/src/jit-test/tests/arrow-functions/params-1.js @@ -0,0 +1,6 @@ +// arrow functions may have empty arguments + +var f = () => 'x'; +assertEq(f.length, 0); +assertEq(f(), 'x'); +assertEq(f(0, 1, 2, 3, 4, 5, 6, 7, 8, 9), 'x'); diff --git a/js/src/jit-test/tests/arrow-functions/params-2.js b/js/src/jit-test/tests/arrow-functions/params-2.js new file mode 100644 index 000000000..a5520166a --- /dev/null +++ b/js/src/jit-test/tests/arrow-functions/params-2.js @@ -0,0 +1,6 @@ +// (a) => expr + +var f = (a) => 2 * a; // parens are allowed +assertEq(f(12), 24); +var g = (a, b) => a + b; +assertEq([1, 2, 3, 4, 5].reduce((a, b) => a + b), 15); diff --git a/js/src/jit-test/tests/arrow-functions/params-default-1.js b/js/src/jit-test/tests/arrow-functions/params-default-1.js new file mode 100644 index 000000000..c4ff50774 --- /dev/null +++ b/js/src/jit-test/tests/arrow-functions/params-default-1.js @@ -0,0 +1,5 @@ +// Parameter default values work in arrow functions + +var f = (a=0) => a + 1; +assertEq(f(), 1); +assertEq(f(50), 51); diff --git a/js/src/jit-test/tests/arrow-functions/params-default-2.js b/js/src/jit-test/tests/arrow-functions/params-default-2.js new file mode 100644 index 000000000..385fc77d7 --- /dev/null +++ b/js/src/jit-test/tests/arrow-functions/params-default-2.js @@ -0,0 +1,6 @@ +// Parameter default values work in arrow functions + +var f = (a=1, b=2, ...rest) => [a, b, rest]; +assertEq(f().toSource(), "[1, 2, []]"); +assertEq(f(0, 0).toSource(), "[0, 0, []]"); +assertEq(f(0, 1, 1, 2, 3, 5).toSource(), "[0, 1, [1, 2, 3, 5]]"); diff --git a/js/src/jit-test/tests/arrow-functions/params-rest-1.js b/js/src/jit-test/tests/arrow-functions/params-rest-1.js new file mode 100644 index 000000000..9d2737a5a --- /dev/null +++ b/js/src/jit-test/tests/arrow-functions/params-rest-1.js @@ -0,0 +1,5 @@ +// Rest parameters are allowed in arrow functions. + +var A = (...x) => x; +assertEq(A().toSource(), "[]"); +assertEq("" + A(3, 4, 5), "3,4,5"); diff --git a/js/src/jit-test/tests/arrow-functions/params-rest-2.js b/js/src/jit-test/tests/arrow-functions/params-rest-2.js new file mode 100644 index 000000000..6668a0aad --- /dev/null +++ b/js/src/jit-test/tests/arrow-functions/params-rest-2.js @@ -0,0 +1,5 @@ +// Rest parameters work in arrow functions + +var f = (a, b, ...rest) => [a, b, rest]; +assertEq(f().toSource(), "[(void 0), (void 0), []]"); +assertEq(f(1, 2, 3, 4).toSource(), "[1, 2, [3, 4]]"); diff --git a/js/src/jit-test/tests/arrow-functions/precedence-1.js b/js/src/jit-test/tests/arrow-functions/precedence-1.js new file mode 100644 index 000000000..f84826cf1 --- /dev/null +++ b/js/src/jit-test/tests/arrow-functions/precedence-1.js @@ -0,0 +1,7 @@ +// || binds tighter than =>. + +var f; +f = a => a || 'nothing'; // f = ((a => a) || 'nothing'); +assertEq(f.length, 1); +assertEq(f(0), 'nothing'); +assertEq(f(1), 1); diff --git a/js/src/jit-test/tests/arrow-functions/precedence-2.js b/js/src/jit-test/tests/arrow-functions/precedence-2.js new file mode 100644 index 000000000..479cb20a4 --- /dev/null +++ b/js/src/jit-test/tests/arrow-functions/precedence-2.js @@ -0,0 +1,6 @@ +// => binds tighter than , + +var f, g; +g = (f, h => h + 1); // sequence expression: (f, (h => h + 1)) +assertEq(g.length, 1); +assertEq(g(37), 38); diff --git a/js/src/jit-test/tests/arrow-functions/precedence-3.js b/js/src/jit-test/tests/arrow-functions/precedence-3.js new file mode 100644 index 000000000..761b17188 --- /dev/null +++ b/js/src/jit-test/tests/arrow-functions/precedence-3.js @@ -0,0 +1,4 @@ +// => binds tighter than , (on the other side) + +var h = (a => a, 13); // sequence expression +assertEq(h, 13); diff --git a/js/src/jit-test/tests/arrow-functions/precedence-4.js b/js/src/jit-test/tests/arrow-functions/precedence-4.js new file mode 100644 index 000000000..ca3e30d6e --- /dev/null +++ b/js/src/jit-test/tests/arrow-functions/precedence-4.js @@ -0,0 +1,6 @@ +// Funny case that looks kind of like default arguments isn't. + +var f = (msg='hi', w=window => w.alert(a, b)); // sequence expression +assertEq(msg, 'hi'); +assertEq(typeof w, 'function'); +assertEq(f, w); diff --git a/js/src/jit-test/tests/arrow-functions/precedence-5.js b/js/src/jit-test/tests/arrow-functions/precedence-5.js new file mode 100644 index 000000000..9418aac0b --- /dev/null +++ b/js/src/jit-test/tests/arrow-functions/precedence-5.js @@ -0,0 +1,3 @@ +// map(x => x, 32) is two arguments, not one + +assertEq("" + [1, 2, 3, 4].map(x => x, 32), "1,2,3,4"); diff --git a/js/src/jit-test/tests/arrow-functions/prototype-1.js b/js/src/jit-test/tests/arrow-functions/prototype-1.js new file mode 100644 index 000000000..57922420f --- /dev/null +++ b/js/src/jit-test/tests/arrow-functions/prototype-1.js @@ -0,0 +1,4 @@ +// The prototype of an arrow function is Function.prototype. + +assertEq(Object.getPrototypeOf(a => a), Function.prototype); +assertEq(Object.getPrototypeOf(() => {}), Function.prototype); diff --git a/js/src/jit-test/tests/arrow-functions/prototype-2.js b/js/src/jit-test/tests/arrow-functions/prototype-2.js new file mode 100644 index 000000000..6573783a9 --- /dev/null +++ b/js/src/jit-test/tests/arrow-functions/prototype-2.js @@ -0,0 +1,4 @@ +// Arrow functions do not have a .prototype property. + +assertEq("prototype" in (a => a), false); +assertEq("prototype" in (() => {}), false); diff --git a/js/src/jit-test/tests/arrow-functions/return-1.js b/js/src/jit-test/tests/arrow-functions/return-1.js new file mode 100644 index 000000000..b89d979e2 --- /dev/null +++ b/js/src/jit-test/tests/arrow-functions/return-1.js @@ -0,0 +1,9 @@ +// return from a block function works when there is no other enclosing function + +var f = a => { + if (a) + return a + 1; + throw "FAIL"; +}; + +assertEq(f(1), 2); diff --git a/js/src/jit-test/tests/arrow-functions/return-2.js b/js/src/jit-test/tests/arrow-functions/return-2.js new file mode 100644 index 000000000..b4ecebb84 --- /dev/null +++ b/js/src/jit-test/tests/arrow-functions/return-2.js @@ -0,0 +1,8 @@ +// return exits the innermost enclosing arrow (not an enclosing function) + +function f() { + var g = x => { return !x; }; + return "f:" + g(true); +} + +assertEq(f(), "f:false"); diff --git a/js/src/jit-test/tests/arrow-functions/return-3.js b/js/src/jit-test/tests/arrow-functions/return-3.js new file mode 100644 index 000000000..09afcbe8e --- /dev/null +++ b/js/src/jit-test/tests/arrow-functions/return-3.js @@ -0,0 +1,8 @@ +// return exits the innermost enclosing arrow (not an enclosing arrow) + +function f() { + var g = a => [0, 1].map(x => { return x + a; }); + return g(13).toSource(); +} + +assertEq(f(), "[13, 14]"); diff --git a/js/src/jit-test/tests/arrow-functions/strict-1.js b/js/src/jit-test/tests/arrow-functions/strict-1.js new file mode 100644 index 000000000..9bb715a4c --- /dev/null +++ b/js/src/jit-test/tests/arrow-functions/strict-1.js @@ -0,0 +1,13 @@ +// arrow functions are not implicitly strict-mode code + +load(libdir + "asserts.js"); + +var f = a => { with (a) return f(); }; +assertEq(f({f: () => 7}), 7); + +f = a => function () { with (a) return f(); }; +assertEq(f({f: () => 7})(), 7); + +f = (a = {x: 1, x: 2}) => b => { "use strict"; return a.x; }; +assertEq(f()(0), 2); + diff --git a/js/src/jit-test/tests/arrow-functions/strict-2.js b/js/src/jit-test/tests/arrow-functions/strict-2.js new file mode 100644 index 000000000..150b2ddb0 --- /dev/null +++ b/js/src/jit-test/tests/arrow-functions/strict-2.js @@ -0,0 +1,11 @@ +// code in arrow function default arguments is strict if arrow is strict + +load(libdir + "asserts.js"); + +assertThrowsInstanceOf( + () => Function("'use strict'; (a = function (obj) { with (obj) f(); }) => { }"), + SyntaxError); + +assertThrowsInstanceOf( + () => Function("'use strict'; (a = obj => { with (obj) f(); }) => { }"), + SyntaxError); diff --git a/js/src/jit-test/tests/arrow-functions/strict-3.js b/js/src/jit-test/tests/arrow-functions/strict-3.js new file mode 100644 index 000000000..24150cfd7 --- /dev/null +++ b/js/src/jit-test/tests/arrow-functions/strict-3.js @@ -0,0 +1,4 @@ +// "use strict" is not special as the body of an arrow function without braces. + +var f = (a = obj => { with (obj) return x; }) => "use strict"; +assertEq(f(), "use strict"); diff --git a/js/src/jit-test/tests/arrow-functions/syntax-errors.js b/js/src/jit-test/tests/arrow-functions/syntax-errors.js new file mode 100644 index 000000000..925fd5b89 --- /dev/null +++ b/js/src/jit-test/tests/arrow-functions/syntax-errors.js @@ -0,0 +1,38 @@ +// Check that we correctly throw SyntaxErrors for various syntactic near-misses. + +load(libdir + "asserts.js"); + +var mistakes = [ + "((a)) => expr", + "a + b => a", + "'' + a => a", + "...x", + "[x] => x", + "([x] => x)", + "{p: p} => p", + "({p: p} => p)", + "{p} => p", + "(...x => expr)", + "1 || a => a", + "'use strict' => {}", + "package => {'use strict';}", // tricky: FutureReservedWord in strict mode code only + "'use strict'; arguments => 0", // names banned in strict mode code + "'use strict'; eval => 0", + "a => {'use strict'; with (a) return x; }", + "a => yield a", + "a => { yield a; }", + "a => { { let x; yield a; } }", + "(a = yield 0) => a", + "for (;;) a => { break; };", + "for (;;) a => { continue; };", + "...rest) =>", + "2 + ...rest) =>" +]; + +for (var s of mistakes) + assertThrowsInstanceOf(function () { Function(s); }, SyntaxError); + +// Check that the tricky case is not an error in non-strict-mode code. +var f = package => 0; +assertEq(f(1), 0); + diff --git a/js/src/jit-test/tests/arrow-functions/this-1.js b/js/src/jit-test/tests/arrow-functions/this-1.js new file mode 100644 index 000000000..136705270 --- /dev/null +++ b/js/src/jit-test/tests/arrow-functions/this-1.js @@ -0,0 +1,17 @@ +// 'this' is lexically scoped in arrow functions + +var obj = { + f: function (expected) { + assertEq(this, expected); + return a => this; + } +}; + +var g = obj.f(obj); +assertEq(g(), obj); + +var obj2 = {f: obj.f}; +var g2 = obj2.f(obj2); +assertEq(g2(), obj2); +assertEq(g(), obj); + diff --git a/js/src/jit-test/tests/arrow-functions/this-2.js b/js/src/jit-test/tests/arrow-functions/this-2.js new file mode 100644 index 000000000..3dac3c863 --- /dev/null +++ b/js/src/jit-test/tests/arrow-functions/this-2.js @@ -0,0 +1,13 @@ +// 'this' is lexically scoped in direct eval code in arrow functions + +var obj = { + f: function (s) { + return a => eval(s); + } +}; + +var g = obj.f("this"); +assertEq(g(), obj); + +var obj2 = {g: g, fail: true}; +assertEq(obj2.g(), obj); diff --git a/js/src/jit-test/tests/arrow-functions/this-3.js b/js/src/jit-test/tests/arrow-functions/this-3.js new file mode 100644 index 000000000..59398a3cb --- /dev/null +++ b/js/src/jit-test/tests/arrow-functions/this-3.js @@ -0,0 +1,13 @@ +// 'this' is lexically scoped in arrow functions in direct eval code + +var obj = { + f: function (s) { + return eval(s); + } +}; + +var g = obj.f("a => this"); +assertEq(g(), obj); + +var obj2 = {g: g, fail: true}; +assertEq(obj2.g(), obj); diff --git a/js/src/jit-test/tests/arrow-functions/this-4.js b/js/src/jit-test/tests/arrow-functions/this-4.js new file mode 100644 index 000000000..0379ef86e --- /dev/null +++ b/js/src/jit-test/tests/arrow-functions/this-4.js @@ -0,0 +1,5 @@ +// 'this' in a toplevel arrow is the global object. + +var f = () => this; +assertEq(f(), this); +assertEq({f: f}.f(), this); diff --git a/js/src/jit-test/tests/arrow-functions/this-5.js b/js/src/jit-test/tests/arrow-functions/this-5.js new file mode 100644 index 000000000..98b7bf816 --- /dev/null +++ b/js/src/jit-test/tests/arrow-functions/this-5.js @@ -0,0 +1,12 @@ +// Arrow functions can have primitive |this| values. + +Number.prototype.foo = function() { + "use strict"; + return () => this; +} + +for (var i=0; i<5; i++) { + var n = i.foo()(); + assertEq(typeof n, "number"); + assertEq(n, i); +} diff --git a/js/src/jit-test/tests/arrow-functions/this-6.js b/js/src/jit-test/tests/arrow-functions/this-6.js new file mode 100644 index 000000000..c5ee4d95a --- /dev/null +++ b/js/src/jit-test/tests/arrow-functions/this-6.js @@ -0,0 +1,11 @@ +// Eval expressions in arrow functions use the correct |this| value. + +function Dog(name) { + this.name = name; + this.getName = () => eval("this.name"); + this.getNameHard = () => eval("(() => this.name)()"); +} + +var d = new Dog("Max"); +assertEq(d.getName(), d.name); +assertEq(d.getNameHard(), d.name); diff --git a/js/src/jit-test/tests/arrow-functions/typeof.js b/js/src/jit-test/tests/arrow-functions/typeof.js new file mode 100644 index 000000000..a610deb91 --- /dev/null +++ b/js/src/jit-test/tests/arrow-functions/typeof.js @@ -0,0 +1,4 @@ +// The typeof an arrow function is "function". + +assertEq(typeof (() => 1), "function"); +assertEq(typeof (a => { return a + 1; }), "function"); |