diff options
Diffstat (limited to 'js/src/tests/non262/syntax')
21 files changed, 1705 insertions, 0 deletions
diff --git a/js/src/tests/non262/syntax/browser.js b/js/src/tests/non262/syntax/browser.js new file mode 100644 index 0000000000..e69de29bb2 --- /dev/null +++ b/js/src/tests/non262/syntax/browser.js diff --git a/js/src/tests/non262/syntax/column-numbers-in-long-lines.js b/js/src/tests/non262/syntax/column-numbers-in-long-lines.js new file mode 100644 index 0000000000..56ce74f86b --- /dev/null +++ b/js/src/tests/non262/syntax/column-numbers-in-long-lines.js @@ -0,0 +1,403 @@ +// |reftest| skip-if(!this.hasOwnProperty('Reflect')||!Reflect.parse) -- uses Reflect.parse(..., { loc: true}) to trigger the column-computing API +/* + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/licenses/publicdomain/ + */ + +//----------------------------------------------------------------------------- +var BUGNUMBER = 1551916; +var summary = + "Optimize computing a column number as count of code points by caching " + + "column numbers (and whether each chunk might contain anything multi-unit) " + + "and counting forward from them"; + +print(BUGNUMBER + ": " + summary); + +/************** + * BEGIN TEST * + **************/ + +// Various testing of column-number computations, with respect to counting as +// code points or units, for very long lines. +// +// This test should pass when column numbers are counts of code points (current +// behavior) or code units (past behavior). It also *should* pass for any valid +// |TokenStreamAnyChars::ColumnChunkLength| value (it must be at least 4 so that +// the maximum-length code point in UTF-8/16 will fit in a single chunk), +// because the value of that constant should be externally invisible save for +// perf effects. (As a result, recompiling and running this test with a variety +// of different values assigned to that constant is a good smoke-test of column +// number computation, that doesn't require having to closely inspect any +// column-related code.) +// +// However, this test is structured on the assumption that that constant has the +// value 128, in order to exercise in targeted fashion various column number +// computation edge cases. +// +// All this testing *could* be written to not be done with |Reflect.parse| -- +// backwards column computations happen even when compiling normal code, in some +// cases. But it's much more the exception than the rule. And |Reflect.parse| +// has *very* predictable column-computation operations (basically start/end +// coordinates are computed immediately when the end of an AST node is reached) +// that make it easier to recognize what the exact pattern of computations for +// which offsets will look like. + +// Helper function for checking node location tersely. +function checkLoc(node, expectedStart, expectedEnd) +{ + let start = node.loc.start; + + assertEq(start.line, expectedStart[0], + "start line number must be as expected"); + assertEq(start.column, expectedStart[1], + "start column number must be as expected"); + + let end = node.loc.end; + + assertEq(end.line, expectedEnd[0], "end line number must be as expected"); + assertEq(end.column, expectedEnd[1], + "end column number must be as expected"); +} + +function lengthInCodePoints(str) +{ + return [...str].length; +} + +// True if column numbers are counts of code points, false otherwise. This +// constant can be used to short-circuit testing that isn't point/unit-agnostic. +const columnsAreCodePoints = (function() +{ + var columnTypes = []; + + function checkColumn(actual, expectedPoints, expectedUnits) + { + if (actual === expectedPoints) + columnTypes.push("p"); + else if (actual === expectedUnits) + columnTypes.push("u"); + else + columnTypes.push("x"); + } + + var script = Reflect.parse('"😱😱😱😱";', { loc: true }); + assertEq(script.type, "Program"); + assertEq(script.loc.start.line, 1); + assertEq(script.loc.end.line, 1); + assertEq(script.loc.start.column, 0); + checkColumn(script.loc.end.column, 7, 11); + + var body = script.body; + assertEq(body.length, 1); + + var stmt = body[0]; + assertEq(stmt.type, "ExpressionStatement"); + assertEq(stmt.loc.start.line, 1); + assertEq(stmt.loc.end.line, 1); + assertEq(stmt.loc.start.column, 0); + checkColumn(stmt.loc.end.column, 7, 11); + + var expr = stmt.expression; + assertEq(expr.type, "Literal"); + assertEq(expr.value, "😱😱😱😱"); + assertEq(expr.loc.start.line, 1); + assertEq(expr.loc.end.line, 1); + assertEq(expr.loc.start.column, 0); + checkColumn(expr.loc.end.column, 6, 10); + + var checkResult = columnTypes.join(","); + + assertEq(checkResult === "p,p,p" || checkResult === "u,u,u", true, + "columns must be wholly code points or units: " + checkResult); + + return checkResult === "p,p,p"; +})(); + +// Start with some basic sanity-testing, without regard to exactly when, how, or +// in what order (offset => column) computations are performed. +function testSimple() +{ + if (!columnsAreCodePoints) + return; + + // Array elements within the full |simpleCode| string constructed below are + // one-element arrays containing the string "😱😱#x" where "#" is the + // character that, in C++, could be written as |'(' + i| where |i| is the + // index of the array within the outer array. + let simpleCodeArray = + [ + 'var Q = [[', // column 0, offset 0 + // REPEAT + '"😱😱(x"],["', // column 10, offset 10 + '😱😱)x"],["😱', // column 20, offset 22 + '😱*x"],["😱😱', // column 30, offset 35 + '+x"],["😱😱,', // column 40, offset 48 + 'x"],["😱😱-x', // column 50, offset 60 + '"],["😱😱.x"', // column 60, offset 72 + '],["😱😱/x"]', // column 70, offset 84 + ',["😱😱0x"],', // column 80, offset 96 + '["😱😱1x"],[', // column 90, offset 108 + // REPEAT + '"😱😱2x"],["', // column 100, offset 120 -- chunk limit between "] + '😱😱3x"],["😱', // column 110, offset 132 + '😱4x"],["😱😱', // column 120, offset 145 + '5x"],["😱😱6', // column 130, offset 158 + 'x"],["😱😱7x', // column 140, offset 170 + '"],["😱😱8x"', // column 150, offset 182 + '],["😱😱9x"]', // column 160, offset 194 + ',["😱😱:x"],', // column 170, offset 206 + '["😱😱;x"],[', // column 180, offset 218 + // REPEAT + '"😱😱<x"],["', // column 190, offset 230 + '😱😱=x"],["😱', // column 200, offset 242 + '😱>x"],["😱😱', // column 210, offset 255 -- chunk limit splits first 😱 + '?x"],["😱😱@', // column 220, offset 268 + 'x"],["😱😱Ax', // column 230, offset 280 + '"],["😱😱Bx"', // column 240, offset 292 + '],["😱😱Cx"]', // column 250, offset 304 + ',["😱😱Dx"],', // column 260, offset 316 + '["😱😱Ex"],[', // column 270, offset 328 + // REPEAT + '"😱😱Fx"],["', // column 280, offset 340 + '😱😱Gx"],["😱', // column 290, offset 352 + '😱Hx"],["😱😱', // column 300, offset 365 + 'Ix"],["😱😱J', // column 310, offset 378 -- chunk limit between [" + 'x"],["😱😱Kx', // column 320, offset 390 + '"],["😱😱Lx"', // column 330, offset 402 + '],["😱😱Mx"]', // column 340, offset 414 + ',["😱😱Nx"],', // column 350, offset 426 + '["😱😱Ox"]];', // column 360 (10 long), offset 438 (+12 to end) + ]; + let simpleCode = simpleCodeArray.join(""); + + // |simpleCode| overall contains this many code points. (This number is + // chosen to be several |TokenStreamAnyChars::ColumnChunkLength = 128| chunks + // long so that long-line handling is exercised, and the relevant vector + // increased in length, for more than one chunk [which would be too short to + // trigger chunking] and for more than two chunks [so that vector extension + // will eventually occur].) + const CodePointLength = 370; + + assertEq(lengthInCodePoints(simpleCode), CodePointLength, + "code point count should be correct"); + + // |simpleCodeArray| contains this many REPEAT-delimited cycles. + const RepetitionNumber = 4; + + // Each cycle consists of this many elements. + const ElementsPerCycle = 9; + + // Each element in a cycle has at least this many 😱. + const MinFaceScreamingPerElementInCycle = 2; + + // Each cycle consists of many elements with three 😱. + const ElementsInCycleWithThreeFaceScreaming = 2; + + // Compute the overall number of UTF-16 code units. (UTF-16 because this is a + // JS string as input.) + const OverallCodeUnitCount = + CodePointLength + + RepetitionNumber * (ElementsPerCycle * MinFaceScreamingPerElementInCycle + + ElementsInCycleWithThreeFaceScreaming); + + // Code units != code points. + assertEq(OverallCodeUnitCount > CodePointLength, true, + "string contains code points outside BMP, so length in units " + + "exceeds length in points"); + + // The overall computed number of code units has this exact numeric value. + assertEq(OverallCodeUnitCount, 450, + "code unit count computation produces this value"); + + // The overall computed number of code units matches the string length. + assertEq(simpleCode.length, OverallCodeUnitCount, "string length must match"); + + // Evaluate the string. + var Q; + eval(simpleCode); + + // Verify characteristics of the resulting execution. + assertEq(Array.isArray(Q), true); + + const NumArrayElements = 40; + assertEq(Q.length, NumArrayElements); + Q.forEach((v, i) => { + assertEq(Array.isArray(v), true); + assertEq(v.length, 1); + assertEq(v[0], "😱😱" + String.fromCharCode('('.charCodeAt(0) + i) + "x"); + }); + + let parseTree = Reflect.parse(simpleCode, { loc: true }); + + // Check the overall script. + assertEq(parseTree.type, "Program"); + checkLoc(parseTree, [1, 0], [1, 370]); + assertEq(parseTree.body.length, 1); + + // Check the coordinates of the declaration. + let varDecl = parseTree.body[0]; + assertEq(varDecl.type, "VariableDeclaration"); + checkLoc(varDecl, [1, 0], [1, 369]); + + // ...and its initializing expression. + let varInit = varDecl.declarations[0].init; + assertEq(varInit.type, "ArrayExpression"); + checkLoc(varInit, [1, 8], [1, 369]); + + // ...and then every literal inside it. + assertEq(varInit.elements.length, NumArrayElements, "array literal length"); + + const ItemLength = lengthInCodePoints('["😱😱#x"],'); + assertEq(ItemLength, 9, "item length check"); + + for (let i = 0; i < NumArrayElements; i++) + { + let elem = varInit.elements[i]; + assertEq(elem.type, "ArrayExpression"); + + let startCol = 9 + i * ItemLength; + let endCol = startCol + ItemLength - 1; + checkLoc(elem, [1, startCol], [1, endCol]); + + let arrayElems = elem.elements; + assertEq(arrayElems.length, 1); + + let str = arrayElems[0]; + assertEq(str.type, "Literal"); + assertEq(str.value, + "😱😱" + String.fromCharCode('('.charCodeAt(0) + i) + "x"); + checkLoc(str, [1, startCol + 1], [1, endCol - 1]); + } +} +testSimple(); + +// Test |ChunkInfo::unitsType() == UnitsType::GuaranteedSingleUnit| -- not that +// it should be observable, precisely, but effects of mis-applying or +// miscomputing it would in principle be observable if such were happening. +// This test also is intended to to be useful for (manually, in a debugger) +// verifying that the optimization is computed and kicks in correctly. +function testGuaranteedSingleUnit() +{ + if (!columnsAreCodePoints) + return; + + // Begin a few array literals in a first chunk to test column computation in + // that first chunk. + // + // End some of them in the first chunk to test columns *before* we know we + // have a long line. + // + // End one array *outside* the first chunk to test a computation inside a + // first chunk *after* we know we have a long line and have computed a first + // chunk. + let mixedChunksCode = "var Z = [ [ [],"; // column 0, offset 0 + assertEq(mixedChunksCode.length, 15); + assertEq(lengthInCodePoints(mixedChunksCode), 15); + + mixedChunksCode += + " ".repeat(128 - mixedChunksCode.length); // column 15, offset 15 + assertEq(mixedChunksCode.length, 128); + assertEq(lengthInCodePoints(mixedChunksCode), 128); + + // Fill out a second chunk as also single-unit, with an outer array literal + // that begins in this chunk but finishes in the next (to test column + // computation in a prior, guaranteed-single-unit chunk). + mixedChunksCode += "[" + "[],".repeat(42) + " "; // column 128, offset 128 + assertEq(mixedChunksCode.length, 256); + assertEq(lengthInCodePoints(mixedChunksCode), 256); + + // Add a third chunk with one last empty nested array literal (so that we + // tack on another chunk, and conclude the second chunk is single-unit, before + // closing the enclosing array literal). Then close the enclosing array + // literal. Finally start a new string literal element containing + // multi-unit code points. For good measure, make the chunk *end* in the + // middle of such a code point, so that the relevant chunk limit must be + // retracted one code unit. + mixedChunksCode += "[] ], '" + "😱".repeat(61); // column 256, offset 256 + assertEq(mixedChunksCode.length, 384 + 1); + assertEq(lengthInCodePoints(mixedChunksCode), 324); + + // Wrap things up. Terminate the string, then terminate the nested array + // literal to trigger a column computation within the first chunk that can + // benefit from knowing the first chunk is all single-unit. Next add a *new* + // element to the outermost array, a string literal that contains a line + // terminator. The terminator invalidates the column computation cache, so + // when the outermost array is closed, location info for it will not hit the + // cache. Finally, tack on the terminating semicolon for good measure. + mixedChunksCode += "' ], '\u2028' ];"; // column 324, offset 385 + assertEq(mixedChunksCode.length, 396); + assertEq(lengthInCodePoints(mixedChunksCode), 335); + + let parseTree = Reflect.parse(mixedChunksCode, { loc: true }); + + // Check the overall script. + assertEq(parseTree.type, "Program"); + checkLoc(parseTree, [1, 0], [2, 4]); + assertEq(parseTree.body.length, 1); + + // Check the coordinates of the declaration. + let varDecl = parseTree.body[0]; + assertEq(varDecl.type, "VariableDeclaration"); + checkLoc(varDecl, [1, 0], [2, 3]); + + // ...and its initializing expression. + let varInit = varDecl.declarations[0].init; + assertEq(varInit.type, "ArrayExpression"); + checkLoc(varInit, [1, 8], [2, 3]); + + let outerArrayElements = varInit.elements; + assertEq(outerArrayElements.length, 2); + + { + // Next the first element, the array inside the initializing expression. + let nestedArray = varInit.elements[0]; + assertEq(nestedArray.type, "ArrayExpression"); + checkLoc(nestedArray, [1, 10], [1, 327]); + + // Now inside that nested array. + let nestedArrayElements = nestedArray.elements; + assertEq(nestedArrayElements.length, 3); + + // First the [] in chunk #0 + let emptyArray = nestedArrayElements[0]; + assertEq(emptyArray.type, "ArrayExpression"); + assertEq(emptyArray.elements.length, 0); + checkLoc(emptyArray, [1, 12], [1, 14]); + + // Then the big array of empty arrays starting in chunk #1 and ending just + // barely in chunk #2. + let bigArrayOfEmpties = nestedArrayElements[1]; + assertEq(bigArrayOfEmpties.type, "ArrayExpression"); + assertEq(bigArrayOfEmpties.elements.length, 42 + 1); + bigArrayOfEmpties.elements.forEach((elem, i) => { + assertEq(elem.type, "ArrayExpression"); + assertEq(elem.elements.length, 0); + if (i !== 42) + checkLoc(elem, [1, 129 + i * 3], [1, 131 + i * 3]); + else + checkLoc(elem, [1, 256], [1, 258]); // last element was hand-placed + }); + + // Then the string literal of multi-unit code points beginning in chunk #2 + // and ending just into chunk #3 on a second line. + let multiUnitStringLiteral = nestedArrayElements[2]; + assertEq(multiUnitStringLiteral.type, "Literal"); + assertEq(multiUnitStringLiteral.value, "😱".repeat(61)); + checkLoc(multiUnitStringLiteral, [1, 262], [1, 325]); + } + + { + // Finally, the string literal containing a line terminator as element in + // the outermost array. + let stringLiteralWithEmbeddedTerminator = outerArrayElements[1]; + assertEq(stringLiteralWithEmbeddedTerminator.type, "Literal"); + assertEq(stringLiteralWithEmbeddedTerminator.value, "\u2028"); + checkLoc(stringLiteralWithEmbeddedTerminator, [1, 329], [2, 1]); + } +} +testGuaranteedSingleUnit(); + +if (typeof reportCompare === "function") + reportCompare(true, true); + +print("Testing completed"); diff --git a/js/src/tests/non262/syntax/declaration-forbidden-in-label.js b/js/src/tests/non262/syntax/declaration-forbidden-in-label.js new file mode 100644 index 0000000000..53acb39961 --- /dev/null +++ b/js/src/tests/non262/syntax/declaration-forbidden-in-label.js @@ -0,0 +1,34 @@ +/* + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/licenses/publicdomain/ + */ + +//----------------------------------------------------------------------------- +var BUGNUMBER = 1288459; +var summary = + "Properly implement the spec's distinctions between StatementListItem and " + + "Statement grammar productions and their uses"; + +print(BUGNUMBER + ": " + summary); + +/************** + * BEGIN TEST * + **************/ + +assertThrowsInstanceOf(() => Function("a: let x;"), SyntaxError); +assertThrowsInstanceOf(() => Function("b: const y = 3;"), SyntaxError); +assertThrowsInstanceOf(() => Function("c: class z {};"), SyntaxError); + +assertThrowsInstanceOf(() => Function("'use strict'; d: function w() {};"), SyntaxError); + +// Annex B.3.2 allows this in non-strict mode code. +Function("e: function x() {};"); + +assertThrowsInstanceOf(() => Function("f: function* y() {}"), SyntaxError); + +/******************************************************************************/ + +if (typeof reportCompare === "function") + reportCompare(true, true); + +print("Tests complete"); diff --git a/js/src/tests/non262/syntax/escaped-let-static-identifier.js b/js/src/tests/non262/syntax/escaped-let-static-identifier.js new file mode 100644 index 0000000000..a4353a516f --- /dev/null +++ b/js/src/tests/non262/syntax/escaped-let-static-identifier.js @@ -0,0 +1,57 @@ +/* + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/licenses/publicdomain/ + */ + +//----------------------------------------------------------------------------- +var BUGNUMBER = 1288460; +var summary = + "|let| and |static| are forbidden as Identifier only in strict mode code, " + + "and it's permissible to use them as Identifier (with or without " + + "containing escapes) in non-strict code"; + +print(BUGNUMBER + ": " + summary); + +/************** + * BEGIN TEST * + **************/ + +function t(code) +{ + var strictSemi = " 'use strict'; " + code; + var strictASI = " 'use strict' \n " + code; + + var creationFunctions = [Function]; + if (typeof evaluate === "function") + creationFunctions.push(evaluate); + if (typeof parseModule === "function") + creationFunctions.push(parseModule); + + for (var func of creationFunctions) + { + if (typeof parseModule === "function" && func === parseModule) + assertThrowsInstanceOf(() => func(code), SyntaxError); + else + func(code); + + assertThrowsInstanceOf(() => func(strictSemi), SyntaxError); + assertThrowsInstanceOf(() => func(strictASI), SyntaxError); + } +} + +t("l\\u0065t: 42;"); +t("if (1) l\\u0065t: 42;"); +t("l\\u0065t = 42;"); +t("if (1) l\\u0065t = 42;"); + +t("st\\u0061tic: 42;"); +t("if (1) st\\u0061tic: 42;"); +t("st\\u0061tic = 42;"); +t("if (1) st\\u0061tic = 42;"); + +/******************************************************************************/ + +if (typeof reportCompare === "function") + reportCompare(true, true); + +print("Tests complete"); diff --git a/js/src/tests/non262/syntax/escaped-strict-reserved-words-and-yield.js b/js/src/tests/non262/syntax/escaped-strict-reserved-words-and-yield.js new file mode 100644 index 0000000000..9d683bd975 --- /dev/null +++ b/js/src/tests/non262/syntax/escaped-strict-reserved-words-and-yield.js @@ -0,0 +1,105 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +const testCases = [ + // Label identifier. + id => `${id}: ;`, + + // Binding identifier. + id => `var ${id};`, + id => `let ${id};`, + id => `const ${id} = 0;`, + + // Binding identifier in binding pattern. + id => `var [${id}] = [];`, + id => `var [${id} = 0] = [];`, + id => `var [...${id}] = [];`, + id => `var {a: ${id}} = {};`, + id => `var {${id}} = {};`, + id => `var {${id} = 0} = {};`, + + id => `let [${id}] = [];`, + id => `let [${id} = 0] = [];`, + id => `let [...${id}] = [];`, + id => `let {a: ${id}} = {};`, + id => `let {${id}} = {};`, + id => `let {${id} = 0} = {};`, + + id => `const [${id}] = [];`, + id => `const [${id} = 0] = [];`, + id => `const [...${id}] = [];`, + id => `const {a: ${id}} = {};`, + id => `const {${id}} = {};`, + id => `const {${id} = 0} = {};`, + + // Identifier reference. + id => `void ${id};`, +]; + +const strictReservedWords = [ + "implements", + "interface", + "package", + "private", + "protected", + "public", +]; + +function escapeWord(s) { + return "\\u00" + s.charCodeAt(0).toString(16) + s.substring(1); +} + +for (let strictReservedWordOrYield of [...strictReservedWords, "yield"]) { + let escapedStrictReservedWordOrYield = escapeWord(strictReservedWordOrYield); + + for (let testCase of testCases) { + eval(testCase(strictReservedWordOrYield)); + eval(testCase(escapedStrictReservedWordOrYield)); + + assertThrowsInstanceOf(() => eval(String.raw` + "use strict"; + ${testCase(strictReservedWordOrYield)} + `), SyntaxError); + + assertThrowsInstanceOf(() => eval(String.raw` + "use strict"; + ${testCase(escapedStrictReservedWordOrYield)} + `), SyntaxError); + } +} + +// |yield| is always a keyword in generator functions. +for (let testCase of testCases) { + let yield = "yield"; + let escapedYield = escapeWord("yield"); + + assertThrowsInstanceOf(() => eval(String.raw` + function* g() { + ${testCase(yield)} + } + `), SyntaxError); + + assertThrowsInstanceOf(() => eval(String.raw` + function* g() { + ${testCase(escapedYield)} + } + `), SyntaxError); + + assertThrowsInstanceOf(() => eval(String.raw` + "use strict"; + function* g() { + ${testCase(yield)} + } + `), SyntaxError); + + assertThrowsInstanceOf(() => eval(String.raw` + "use strict"; + function* g() { + ${testCase(escapedYield)} + } + `), SyntaxError); +} + +if (typeof reportCompare === "function") + reportCompare(0, 0, "ok"); diff --git a/js/src/tests/non262/syntax/identifier_vertical_tilde.js b/js/src/tests/non262/syntax/identifier_vertical_tilde.js new file mode 100644 index 0000000000..94fb55f637 --- /dev/null +++ b/js/src/tests/non262/syntax/identifier_vertical_tilde.js @@ -0,0 +1,20 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +// U+2E2F (VERTICAL TILDE) is in Gc=Lm, but also in [:Pattern_Syntax:]. +// http://www.unicode.org/reports/tr31/ +const verticalTilde = 0x2E2F; + +// Leading character in identifier. +assertThrowsInstanceOf(() => eval(`${String.fromCodePoint(verticalTilde)}`), SyntaxError); +assertThrowsInstanceOf(() => eval(`\\u${verticalTilde.toString(16).padStart(4, "0")}`), SyntaxError); +assertThrowsInstanceOf(() => eval(`\\u{${verticalTilde.toString(16)}}`), SyntaxError); + +// Not leading character in identifier. +assertThrowsInstanceOf(() => eval(`A${String.fromCodePoint(verticalTilde)}`), SyntaxError); +assertThrowsInstanceOf(() => eval(`A\\u${verticalTilde.toString(16).padStart(4, "0")}`), SyntaxError); +assertThrowsInstanceOf(() => eval(`A\\u{${verticalTilde.toString(16)}}`), SyntaxError); + +if (typeof reportCompare === "function") + reportCompare(0, 0, "ok"); diff --git a/js/src/tests/non262/syntax/identifiers-with-extended-unicode-escape.js b/js/src/tests/non262/syntax/identifiers-with-extended-unicode-escape.js new file mode 100644 index 0000000000..e4b5f46029 --- /dev/null +++ b/js/src/tests/non262/syntax/identifiers-with-extended-unicode-escape.js @@ -0,0 +1,208 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +// Simple cases, not using eval. +{ + let \u{61} = 123; + assertEq(a, 123); + + let \u{6A} = 123; + assertEq(j, 123); + + let a\u{62} = 456; + assertEq(ab, 456); + + let \u{63}\u{6b} = 789; + assertEq(ck, 789); +} + +const leadingZeros = [0, 1, 2, 3, 4, 100].map(c => "0".repeat(c)); + + +// From DerivedCoreProperties.txt (Unicode 9): +// Derived Property: ID_Start +// Characters that can start an identifier. +// Generated from: +// Lu + Ll + Lt + Lm + Lo + Nl +// + Other_ID_Start +// - Pattern_Syntax +// - Pattern_White_Space +const idStart = [ + 0x0041, // LATIN CAPITAL LETTER A, Gc=Lu + 0x006A, // LATIN SMALL LETTER J, Gc=Ll + 0x00C9, // LATIN CAPITAL LETTER E WITH ACUTE, Gc=Lu + 0x00FF, // LATIN SMALL LETTER Y WITH DIAERESIS, Gc=Ll + 0x01C5, // LATIN CAPITAL LETTER D WITH SMALL LETTER Z WITH CARON, Gc=Lt + 0x0294, // LATIN LETTER GLOTTAL STOP, Gc=Lo + 0x037A, // GREEK YPOGEGRAMMENI, Gc=Lm + 0x16EE, // RUNIC ARLAUG SYMBOL, Gc=Nl + 0xFF70, // HALFWIDTH KATAKANA-HIRAGANA PROLONGED SOUND MARK, Gc=Lm +]; + +const idStartSupplemental = [ + 0x10140, // GREEK ACROPHONIC ATTIC ONE QUARTER, Gc=Nl + 0x10300, // OLD ITALIC LETTER A, Gc=Lo + 0x10400, // DESERET CAPITAL LETTER LONG I, Gc=Lu + 0x10430, // DESERET SMALL LETTER SHORT A, Gc=Ll + 0x16B40, // PAHAWH HMONG SIGN VOS SEEV, Gc=Lm +]; + +// From PropList.txt (Unicode 9): +const otherIdStart = [ + 0x1885, // MONGOLIAN LETTER ALI GALI BALUDA, Gc=Mn + 0x1886, // MONGOLIAN LETTER ALI GALI THREE BALUDA, Gc=Mn + 0x2118, // SCRIPT CAPITAL P, Gc=Sm + 0x212E, // ESTIMATED SYMBOL, Gc=So + 0x309B, // KATAKANA-HIRAGANA VOICED SOUND MARK, Gc=Sk + 0x309C, // KATAKANA-HIRAGANA SEMI-VOICED SOUND MARK, Gc=Sk +]; + +// From DerivedCoreProperties.txt (Unicode 9): +// Derived Property: ID_Continue +// Characters that can continue an identifier. +// Generated from: +// ID_Start +// + Mn + Mc + Nd + Pc +// + Other_ID_Continue +// - Pattern_Syntax +// - Pattern_White_Space +const idContinue = [ + 0x0030, // DIGIT ZERO, Gc=Nd + 0x0300, // COMBINING GRAVE ACCENT, Gc=Mn + 0x0660, // ARABIC-INDIC DIGIT ZERO, Gc=Nd + 0x0903, // DEVANAGARI SIGN VISARGA, Gc=Mc + 0xFF10, // FULLWIDTH DIGIT ZERO, Gc=Nd + 0xFF3F, // FULLWIDTH LOW LINE, Gc=Pc +]; + +const idContinueSupplemental = [ + 0x101FD, // PHAISTOS DISC SIGN COMBINING OBLIQUE STROKE, Gc=Mn + 0x104A0, // OSMANYA DIGIT ZERO, Gc=Nd + 0x11000, // BRAHMI SIGN CANDRABINDU, Gc=Mc +]; + +// From PropList.txt (Unicode 9): +const otherIdContinue = [ + 0x00B7, // MIDDLE DOT, Gc=Po + 0x0387, // GREEK ANO TELEIA, Gc=Po + 0x1369, // ETHIOPIC DIGIT ONE, Gc=No + 0x136A, // ETHIOPIC DIGIT TWO, Gc=No + 0x136B, // ETHIOPIC DIGIT THREE, Gc=No + 0x136C, // ETHIOPIC DIGIT FOUR, Gc=No + 0x136D, // ETHIOPIC DIGIT FIVE, Gc=No + 0x136E, // ETHIOPIC DIGIT SIX, Gc=No + 0x136F, // ETHIOPIC DIGIT SEVEN, Gc=No + 0x1370, // ETHIOPIC DIGIT EIGHT, Gc=No + 0x1371, // ETHIOPIC DIGIT NINE, Gc=No + 0x19DA, // NEW TAI LUE THAM DIGIT ONE, Gc=No +]; + +for (let ident of [...idStart, ...otherIdStart, ...idStartSupplemental]) { + for (let count of leadingZeros) { + let zeros = "0".repeat(count); + eval(` + let \\u{${zeros}${ident.toString(16)}} = 123; + assertEq(${String.fromCodePoint(ident)}, 123); + `); + } +} + +for (let ident of [...idContinue, ...idContinueSupplemental, ...otherIdContinue]) { + for (let zeros of leadingZeros) { + assertThrowsInstanceOf(() => eval(`\\u{${zeros}${ident.toString(16)}}`), SyntaxError); + } +} + +for (let ident of [...idStart, ...otherIdStart, ...idContinue, ...otherIdContinue, ...idStartSupplemental, ...idContinueSupplemental]) { + for (let zeros of leadingZeros) { + eval(` + let A\\u{${zeros}${ident.toString(16)}} = 123; + assertEq(${String.fromCodePoint(0x41, ident)}, 123); + `); + } +} + + +const notIdentifiers = [ + 0x0000, // NULL, Gc=Cc + 0x000A, // LINE FEED (LF), Gc=Cc + 0x005E, // CIRCUMFLEX ACCENT, Gc=Sk + 0x00B1, // PLUS-MINUS SIGN, Gc=Sm + 0xFF61, // HALFWIDTH IDEOGRAPHIC FULL STOP, Gc=Po + 0x10061, // Not assigned. + 0x10100, // AEGEAN WORD SEPARATOR LINE, Gc=Po + 0x100061, // <Plane 16 Private Use>, Gc=Co +]; + +for (let ident of notIdentifiers) { + for (let zeros of leadingZeros) { + assertThrowsInstanceOf(() => eval(`\\u{${zeros}${ident.toString(16)}}`), SyntaxError); + } +} + + +const incompleteEscapes = [ + "\\u{", + "\\u{6", + "\\u{61", + "\\u{061", + "\\u{0061", + "\\u{00061", + "\\u{000061", + "\\u{0000061", + + "\\u}", +]; +for (let invalid of incompleteEscapes) { + // Ends with EOF. + assertThrowsInstanceOf(() => eval(invalid), SyntaxError); + + // Ends with EOL. + assertThrowsInstanceOf(() => eval(invalid + "\n"), SyntaxError); + + // Ends with space. + assertThrowsInstanceOf(() => eval(invalid + " "), SyntaxError); +} + + +const invalidEscapes = [ + // Empty escape. + "", + + // Not hexadecimal characters. + "\0", + "G", + "Z", + "\uFFFF", + "\uDBFF\uDFFF", + + // Has space characters. + " 61", + "61 ", + + // Has newline characters. + "\n61", + "61\n", + + // Exceeds 0x10FFFF, six characters. + "110000", + "110001", + "fffffe", + "ffffff", + + // Exceeds 0x10FFFF, more than six characters. + "10ffff0", + "10ffffabcdef", +]; + +for (let invalid of invalidEscapes) { + for (let zeros of leadingZeros) { + assertThrowsInstanceOf(() => eval(`\\u{${zeros}${invalid}}`), SyntaxError); + assertThrowsInstanceOf(() => eval(`var \\u{${zeros}${invalid}}`), SyntaxError); + } +} + + +if (typeof reportCompare === "function") + reportCompare(0, 0, "ok"); diff --git a/js/src/tests/non262/syntax/keyword-unescaped-requirement.js b/js/src/tests/non262/syntax/keyword-unescaped-requirement.js new file mode 100644 index 0000000000..eb6edd57db --- /dev/null +++ b/js/src/tests/non262/syntax/keyword-unescaped-requirement.js @@ -0,0 +1,68 @@ +/* + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/licenses/publicdomain/ + */ + +//----------------------------------------------------------------------------- +var BUGNUMBER = 1204027; +var summary = + "Escape sequences aren't allowed in bolded grammar tokens (that is, in " + + "keywords, possibly contextual keywords)"; + +print(BUGNUMBER + ": " + summary); + +/************** + * BEGIN TEST * + **************/ + +function memberVariants(code) +{ + return ["(class { constructor() {} " + code + " });", + "({ " + code + " })"]; +} + +var badScripts = + [ + "class { st\\u0061tic m() { return 0; } }", + "class { st\\u0061tic get foo() { return 0; } }", + "class { st\\u0061tic set foo(v) {} }", + "class { st\\u0061tic get ['hi']() { return 0; } }", + "class { st\\u0061tic set ['hi'](v) {} }", + "class { st\\u0061tic get 'hi'() { return 0; } }", + "class { st\\u0061tic set 'hi'(v) {} }", + "class { st\\u0061tic get 42() { return 0; } }", + "class { st\\u0061tic set 42(v) {} }", + ...memberVariants("\\u0067et foo() { return 0; }"), + ...memberVariants("\\u0073et foo() {}"), + ...memberVariants("g\\u0065t foo() { return 0; }"), + ...memberVariants("s\\u0065t foo() {}"), + ...memberVariants("g\\u0065t ['hi']() { return 0; }"), + ...memberVariants("s\\u0065t ['hi']() {}"), + ...memberVariants("g\\u0065t 'hi'() { return 0; }"), + ...memberVariants("s\\u0065t 'hi'() {}"), + ...memberVariants("g\\u0065t 42() { return 0; }"), + ...memberVariants("s\\u0065t 42() {}"), + "for (var foo o\\u0066 [1]) ;", + "for (var foo \\u006ff [1]) ;", + "for (var foo i\\u006e [1]) ;", + "for (var foo \\u0069n [1]) ;", + "function f() { return n\\u0065w.target }", + "function f() { return \\u006eew.target }", + "function f() { return new.t\\u0061rget }", + "function f() { return new.\\u0074arget }", + "function f() { return n\\u0065w Array }", + "function f() { return \\u006eew Array }", + "\\u0064o { } while (0)", + "[for (x \\u006ff [1]) x]", + "[for (x o\\u0066 [1]) x]", + ]; + +for (var script of badScripts) + assertThrowsInstanceOf(() => Function(script), SyntaxError); + +/******************************************************************************/ + +if (typeof reportCompare === "function") + reportCompare(true, true); + +print("Tests complete"); diff --git a/js/src/tests/non262/syntax/let-as-label.js b/js/src/tests/non262/syntax/let-as-label.js new file mode 100644 index 0000000000..a01ad556e1 --- /dev/null +++ b/js/src/tests/non262/syntax/let-as-label.js @@ -0,0 +1,35 @@ +/* + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/licenses/publicdomain/ + */ + +//----------------------------------------------------------------------------- +var BUGNUMBER = 1288459; +var summary = "let can't be used as a label in strict mode code"; + +print(BUGNUMBER + ": " + summary); + +/************** + * BEGIN TEST * + **************/ + +Function("let: 42"); +Function("l\\u0065t: 42"); +assertThrowsInstanceOf(() => Function(" 'use strict'; let: 42"), SyntaxError); +assertThrowsInstanceOf(() => Function(" 'use strict' \n let: 42"), SyntaxError); +assertThrowsInstanceOf(() => Function(" 'use strict'; l\\u0065t: 42"), SyntaxError); +assertThrowsInstanceOf(() => Function(" 'use strict' \n l\\u0065t: 42"), SyntaxError); + +eval("let: 42"); +eval("l\\u0065t: 42"); +assertThrowsInstanceOf(() => eval(" 'use strict'; let: 42"), SyntaxError); +assertThrowsInstanceOf(() => eval(" 'use strict' \n let: 42;"), SyntaxError); +assertThrowsInstanceOf(() => eval(" 'use strict'; l\\u0065t: 42"), SyntaxError); +assertThrowsInstanceOf(() => eval(" 'use strict' \n l\\u0065t: 42;"), SyntaxError); + +/******************************************************************************/ + +if (typeof reportCompare === "function") + reportCompare(true, true); + +print("Tests complete"); diff --git a/js/src/tests/non262/syntax/line-number-maintenance-for-identifier-containing-escape-terminated-by-unicode-separator.js b/js/src/tests/non262/syntax/line-number-maintenance-for-identifier-containing-escape-terminated-by-unicode-separator.js new file mode 100644 index 0000000000..4293cbb0a2 --- /dev/null +++ b/js/src/tests/non262/syntax/line-number-maintenance-for-identifier-containing-escape-terminated-by-unicode-separator.js @@ -0,0 +1,41 @@ +/* + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/licenses/publicdomain/ + */ + +//----------------------------------------------------------------------------- +var BUGNUMBER = 9999999; +var summary = + "Properly maintain the line number when tokenizing identifiers that " + + "contain Unicode escapes *and* are terminated by U+2028 LINE SEPARATOR " + + "or U+2029 PARAGRAPH SEPARATOR"; + +print(BUGNUMBER + ": " + summary); + +/************** + * BEGIN TEST * + **************/ + +var code = "var a\u0062c = [];\n"; // line 1 + +for (var i = 0; i < 100; i++) + code += "a\\u0062c\u2028a\\u0062c\u2029"; // lines 2..2+200-1 + +code += "@"; // line 2+200 + +try +{ + eval(code); + throw new Error("didn't throw"); +} +catch (e) +{ + assertEq(e.lineNumber, 2 + 200); +} + +/******************************************************************************/ + +if (typeof reportCompare === "function") + reportCompare(true, true); + +print("Tests complete"); diff --git a/js/src/tests/non262/syntax/linefeed-at-eof-in-unterminated-string-or-template.js b/js/src/tests/non262/syntax/linefeed-at-eof-in-unterminated-string-or-template.js new file mode 100644 index 0000000000..461f61ebd3 --- /dev/null +++ b/js/src/tests/non262/syntax/linefeed-at-eof-in-unterminated-string-or-template.js @@ -0,0 +1,88 @@ +/* + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/licenses/publicdomain/ + */ + +//----------------------------------------------------------------------------- +var BUGNUMBER = 1476409; +var summary = + "Properly handle the case of U+005C REVERSE SOLIDUS U+000D CARRIAGE RETURN " + + "at the end of source text being tokenized, in the middle of a string or " + + "template literal, where the next code point in memory (outside the bounds " + + "of the source text) is U+000A LINE FEED"; + +print(BUGNUMBER + ": " + summary); + +/************** + * BEGIN TEST * + **************/ + +function expectSyntaxError(code) +{ + try + { + eval(code); + throw new Error("didn't throw"); + } + catch (e) + { + assertEq(e instanceof SyntaxError, true, + "got " + e.name + ", expected SyntaxError"); + } +} + +// The fundamental requirements of this test: +// +// 1. The computed string that is eval'd must be a Script that ends in a string +// literal ending with the code points U+005C REVERSE SOLIDUS U+000D CARRIAGE +// RETURN. +// 2. The *memory* that is actually tokenized/parsed by eval must be +// immediately followed by U+000A LINE FEED. +// +// There's only one way to guarantee a U+000A LINE FEED after the source text: +// compute the source text as a dependent string, of a larger (linear) string. +// A simple substr will do the trick -- just as long as the substring can't fit +// in inline storage. 53 in the tests below comfortably exceeds all inline +// storage limits. +// +// One final wrinkle: because we only tokenize/parse two-byte source text right +// now, ensuring we directly tokenize/parse the dependent string's character +// data means the dependent string must have two-byte character data, hence the +// '\u1234' in the strings below. + +function singleQuote() +{ + var containsBadSingleQuoteLiteral = + "\u1234x'01234567890123456789012345678901234567890123456789\\\r\n0123456789"; + // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + expectSyntaxError(containsBadSingleQuoteLiteral.substr(2, 53)); +} +singleQuote(); + +function doubleQuote() +{ + var containsBadDoubleQuoteLiteral = + "\u1234x\"01234567890123456789012345678901234567890123456789\\\r\n0123456789"; + // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + expectSyntaxError(containsBadDoubleQuoteLiteral.substr(2, 53)); +} +doubleQuote(); + +function template() +{ + var containsBadTemplateLiteral = + "\u1234x`01234567890123456789012345678901234567890123456789\\\r\n0123456789"; + // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + expectSyntaxError(containsBadTemplateLiteral.substr(2, 53)); +} +template(); + +/******************************************************************************/ + +if (typeof reportCompare === "function") + reportCompare(true, true); + +print("Tests complete"); diff --git a/js/src/tests/non262/syntax/non-simple-with-strict-directive.js b/js/src/tests/non262/syntax/non-simple-with-strict-directive.js new file mode 100644 index 0000000000..a0e5366879 --- /dev/null +++ b/js/src/tests/non262/syntax/non-simple-with-strict-directive.js @@ -0,0 +1,140 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +const testCases = [ + // Array destructuring. + "[]", + "[a]", + "x, [a]", + "[a], x", + + // Array destructuring with defaults. + "[a = 0]", + "x, [a = 0]", + "[a = 0], x", + + // Array destructuring with rest binding identifier. + "[...a]", + "x, [...a]", + "[...a], x", + + // Array destructuring with rest binding pattern. + "[...[a]]", + "x, [...[a]]", + "[...[a]], x", + + // Object destructuring. + "{}", + "{p: o}", + "x, {p: o}", + "{p: o}, x", + + // Object destructuring with defaults. + "{p: o = 0}", + "x, {p: o = 0}", + "{p: o = 0}, x", + + // Object destructuring with shorthand identifier form. + "{o}", + "x, {o}", + "{o}, x", + + // Object destructuring with CoverInitName. + "{o = 0}", + "x, {o = 0}", + "{o = 0}, x", + + // Default parameter. + "d = 0", + "x, d = 0", + "d = 0, x", + + // Rest parameter. + "...rest", + "x, ...rest", + + // Rest parameter with array destructuring. + "...[]", + "...[a]", + "x, ...[]", + "x, ...[a]", + + // Rest parameter with object destructuring. + "...{}", + "...{p: o}", + "x, ...{}", + "x, ...{p: o}", + + // All non-simple cases combined. + "x, d = 123, [a], {p: 0}, ...rest", +]; + +const GeneratorFunction = function*(){}.constructor; + +const functionDefinitions = [ + // FunctionDeclaration + parameters => `function f(${parameters}) { "use strict"; }`, + + // FunctionExpression + parameters => `void function(${parameters}) { "use strict"; };`, + parameters => `void function f(${parameters}) { "use strict"; };`, + + // Function constructor + parameters => `Function('${parameters}', '"use strict";')`, + + // GeneratorDeclaration + parameters => `function* g(${parameters}) { "use strict"; }`, + + // GeneratorExpression + parameters => `void function*(${parameters}) { "use strict"; };`, + parameters => `void function* g(${parameters}) { "use strict"; };`, + + // GeneratorFunction constructor + parameters => `GeneratorFunction('${parameters}', '"use strict";')`, + + // MethodDefinition + parameters => `({ m(${parameters}) { "use strict"; } });`, + parameters => `(class { m(${parameters}) { "use strict"; } });`, + parameters => `class C { m(${parameters}) { "use strict"; } }`, + + // MethodDefinition (constructors) + parameters => `(class { constructor(${parameters}) { "use strict"; } });`, + parameters => `class C { constructor(${parameters}) { "use strict"; } }`, + + // MethodDefinition (getter) + parameters => `({ get m(${parameters}) { "use strict"; } });`, + parameters => `(class { get m(${parameters}) { "use strict"; } });`, + parameters => `class C { get m(${parameters}) { "use strict"; } }`, + + // MethodDefinition (setter) + parameters => `({ set m(${parameters}) { "use strict"; } });`, + parameters => `(class { set m(${parameters}) { "use strict"; } });`, + parameters => `class C { set m(${parameters}) { "use strict"; } }`, + + // GeneratorMethod + parameters => `({ *m(${parameters}) { "use strict"; } });`, + parameters => `(class { *m(${parameters}) { "use strict"; } });`, + parameters => `class C { *m(${parameters}) { "use strict"; } }`, + + // ArrowFunction + parameters => `(${parameters}) => { "use strict"; };`, +]; + +for (let nonSimpleParameters of testCases) { + for (let def of functionDefinitions) { + // Non-strict script code. + assertThrowsInstanceOf(() => eval(` + ${def(nonSimpleParameters)} + `), SyntaxError, def(nonSimpleParameters)); + + // Strict script code. + assertThrowsInstanceOf(() => eval(` + "use strict"; + ${def(nonSimpleParameters)} + `), SyntaxError, `"use strict"; ${def(nonSimpleParameters)}`); + } +} + +if (typeof reportCompare === 'function') + reportCompare(0, 0); diff --git a/js/src/tests/non262/syntax/omitted-catch-binding.js b/js/src/tests/non262/syntax/omitted-catch-binding.js new file mode 100644 index 0000000000..86b3c0f4f8 --- /dev/null +++ b/js/src/tests/non262/syntax/omitted-catch-binding.js @@ -0,0 +1,36 @@ +var state = 'initial'; +try { + throw new Error('caught'); + state = 'unreachable'; +} catch { // Note the lack of a binding + assertEq(state, 'initial'); + state = 'caught'; +} +assertEq(state, 'caught'); + + +var sigil1 = {}; +try { + throw sigil1; +} catch (e) { + assertEq(e, sigil1); +} + + +var sigil2 = {}; +var reached = false; +try { + try { + throw sigil1; + } catch { + reached = true; + } finally { + throw sigil2; + } +} catch (e) { + assertEq(e, sigil2); +} +assertEq(reached, true); + +if (typeof reportCompare === "function") + reportCompare(0, 0); diff --git a/js/src/tests/non262/syntax/shell.js b/js/src/tests/non262/syntax/shell.js new file mode 100644 index 0000000000..e69de29bb2 --- /dev/null +++ b/js/src/tests/non262/syntax/shell.js diff --git a/js/src/tests/non262/syntax/statement-versus-statementlistitem.js b/js/src/tests/non262/syntax/statement-versus-statementlistitem.js new file mode 100644 index 0000000000..d0565353dd --- /dev/null +++ b/js/src/tests/non262/syntax/statement-versus-statementlistitem.js @@ -0,0 +1,148 @@ +// |reftest| skip-if(!xulRuntime.shell) -- needs evaluate, parseModule +/* + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/licenses/publicdomain/ + */ + +//----------------------------------------------------------------------------- +var BUGNUMBER = 1288459; +var summary = + "Properly implement the spec's distinctions between StatementListItem and " + + "Statement grammar productions and their uses"; + +print(BUGNUMBER + ": " + summary); + +/************** + * BEGIN TEST * + **************/ + +var counter = 0; + +// Test all the different contexts that expect a Statement. + +function contextAcceptsStatement(pat) +{ + var goodCode = +`function f${counter++}() +{ + ${pat.replace("@@@", "let \n {} \n ;")} +} +`; + + evaluate(goodCode); + + var badCode = +`function f${counter++}() +{ + ${pat.replace("@@@", "let {} \n ;")} +} +`; + + try + { + evaluate(badCode); + throw new Error("didn't throw"); + } + catch (e) + { + assertEq(e instanceof SyntaxError, true, + "didn't get a syntax error, instead got: " + e); + } +} + +contextAcceptsStatement("if (0) @@@"); +contextAcceptsStatement("if (0) ; else @@@"); +contextAcceptsStatement("if (0) ; else if (0) @@@"); +contextAcceptsStatement("if (0) ; else if (0) ; else @@@"); +// Can't test do-while loops this way because the Statement isn't in trailing +// position, so 'let' followed by newline *must* be followed by 'while'. +contextAcceptsStatement("while (1) @@@"); +contextAcceptsStatement("for (1; 1; 0) @@@"); +contextAcceptsStatement("for (var x; 1; 0) @@@"); +contextAcceptsStatement("for (let x; 1; 0) @@@"); +contextAcceptsStatement("for (const x = 1; 1; 0) @@@"); +contextAcceptsStatement("for (x in 0) @@@"); +contextAcceptsStatement("for (var x in 0) @@@"); +contextAcceptsStatement("for (let x in 0) @@@"); +contextAcceptsStatement("for (const x in 0) @@@"); +contextAcceptsStatement("for (x of []) @@@"); +contextAcceptsStatement("for (var x of []) @@@"); +contextAcceptsStatement("for (let x of []) @@@"); +contextAcceptsStatement("for (const x of []) @@@"); +contextAcceptsStatement("with (1) @@@"); +contextAcceptsStatement("foo: @@@"); + +// Test all the different contexts that expect a StatementListItem. + +function contextAcceptsStatementListItem(pat) +{ + var goodCode = +`function f${counter++}() +{ + ${pat.replace("@@@", "let \n [] = [] ;")} +} +`; + + evaluate(goodCode); + + var moarGoodCode = pat.replace("@@@", "let \n [] = [] ;"); + evaluate(moarGoodCode); + + var goodModuleCode = pat.replace("@@@", "let \n [] = [] ;"); + parseModule(goodModuleCode); + + var badCode = +`function f${counter++}() +{ + ${pat.replace("@@@", "let \n let = 3 ;")} +} +`; + + try + { + evaluate(badCode); + throw new Error("didn't throw"); + } + catch (e) + { + assertEq(e instanceof SyntaxError, true, + "didn't get a syntax error, instead got: " + e); + } +} + +contextAcceptsStatementListItem("{ @@@ }"); +contextAcceptsStatementListItem("switch (1) { case 1: @@@ }"); +contextAcceptsStatementListItem("switch (1) { default: @@@ }"); +contextAcceptsStatementListItem("switch (1) { case 0: case 1: @@@ }"); +contextAcceptsStatementListItem("switch (1) { case 0: break; case 1: @@@ }"); +contextAcceptsStatementListItem("switch (1) { default: @@@ case 2: }"); +contextAcceptsStatementListItem("try { @@@ } catch (e) { }"); +contextAcceptsStatementListItem("try { @@@ } finally { }"); +contextAcceptsStatementListItem("try { @@@ } catch (e) { } finally { }"); +contextAcceptsStatementListItem("try { } catch (e) { @@@ }"); +contextAcceptsStatementListItem("try { } finally { @@@ }"); +contextAcceptsStatementListItem("try { } catch (e) { @@@ } finally { }"); +contextAcceptsStatementListItem("try { } catch (e) { } finally { @@@ }"); +contextAcceptsStatementListItem("_ => { @@@ }"); +contextAcceptsStatementListItem("function q() { @@@ }"); +contextAcceptsStatementListItem("function* q() { @@@ }"); +contextAcceptsStatementListItem("(function() { @@@ })"); +contextAcceptsStatementListItem("(function*() { @@@ })"); +contextAcceptsStatementListItem("({ *q() { @@@ } })"); +contextAcceptsStatementListItem("({ q() { @@@ } })"); +contextAcceptsStatementListItem("({ get q() { @@@ } })"); +contextAcceptsStatementListItem("({ set q(v) { @@@ } })"); +contextAcceptsStatementListItem("(class { f() { @@@ } })"); +contextAcceptsStatementListItem("(class { static f() { @@@ } })"); +contextAcceptsStatementListItem("(class { static *f() { @@@ } })"); +contextAcceptsStatementListItem("(class { static get f() { @@@ } })"); +contextAcceptsStatementListItem("(class { static set f(v) { @@@ } })"); +contextAcceptsStatementListItem("(class { static() { @@@ } })"); +contextAcceptsStatementListItem("@@@"); + +/******************************************************************************/ + +if (typeof reportCompare === "function") + reportCompare(true, true); + +print("Tests complete"); diff --git a/js/src/tests/non262/syntax/syntax-parsed-arrow-then-bigint.js b/js/src/tests/non262/syntax/syntax-parsed-arrow-then-bigint.js new file mode 100644 index 0000000000..d7a4ccd092 --- /dev/null +++ b/js/src/tests/non262/syntax/syntax-parsed-arrow-then-bigint.js @@ -0,0 +1,40 @@ +/* + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/licenses/publicdomain/ + */ + +//----------------------------------------------------------------------------- +var BUGNUMBER = 1596706; +var summary = + "Properly evaluate a bigint literal that's initially tokenized by a syntax " + + "parser (because the bigint literal appears immediately after an arrow " + + "function with expression body)"; + +print(BUGNUMBER + ": " + summary); + +/************** + * BEGIN TEST * + **************/ + +// block followed by semicolon +assertEq(eval(`x=>{}; +17n`), 17n); + +// block not followed by semicolon +assertEq(eval(`x=>{} +42n`), 42n); + +// expr followed by semicolon +assertEq(eval(`x=>y; +8675309n`), 8675309n); + +// expr not followed by semicolon +assertEq(eval(`x=>y +78051120n`), 78051120n); + +/******************************************************************************/ + +if (typeof reportCompare === "function") + reportCompare(true, true); + +print("Tests complete"); diff --git a/js/src/tests/non262/syntax/syntax-parsed-arrow-then-directive.js b/js/src/tests/non262/syntax/syntax-parsed-arrow-then-directive.js new file mode 100644 index 0000000000..9be9c3fca6 --- /dev/null +++ b/js/src/tests/non262/syntax/syntax-parsed-arrow-then-directive.js @@ -0,0 +1,72 @@ +/* + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/licenses/publicdomain/ + */ + +//----------------------------------------------------------------------------- +var BUGNUMBER = 1596706; +var summary = + "Properly apply a directive comment that's only tokenized by a syntax " + + "parser (because the directive comment appears immediately after an arrow " + + "function with expression body)"; + +print(BUGNUMBER + ": " + summary); + +/************** + * BEGIN TEST * + **************/ + +var stack; + +function reset() +{ + stack = ""; +} + +function assertStackContains(needle, msg) +{ + assertEq(stack.indexOf(needle) >= 0, true, + `stack should contain '${needle}': ${msg}`); +} + +Object.defineProperty(this, "detectSourceURL", { + get() { + stack = new Error().stack; + return 17; + } +}); + +// block followed by semicolon +reset(); +assertEq(eval(`x=>{}; +//# sourceURL=http://example.com/foo.js +detectSourceURL`), 17); +assertStackContains("http://example.com/foo.js", "block, semi"); + +// block not followed by semicolon +reset(); +assertEq(eval(`x=>{} +//# sourceURL=http://example.com/bar.js +detectSourceURL`), 17); +assertStackContains("http://example.com/bar.js", "block, not semi"); + +// expr followed by semicolon +reset(); +assertEq(eval(`x=>y; +//# sourceURL=http://example.com/baz.js +detectSourceURL`), 17); +assertStackContains("http://example.com/baz.js", "expr, semi"); + +// expr not followed by semicolon +reset(); +assertEq(eval(`x=>y +//# sourceURL=http://example.com/quux.js +detectSourceURL`), 17); +assertStackContains("http://example.com/quux.js", "expr, not semi"); + +/******************************************************************************/ + +if (typeof reportCompare === "function") + reportCompare(true, true); + +print("Tests complete"); diff --git a/js/src/tests/non262/syntax/syntax-parsed-arrow-then-sourcemap-directive.js b/js/src/tests/non262/syntax/syntax-parsed-arrow-then-sourcemap-directive.js new file mode 100644 index 0000000000..71e2b2bdaf --- /dev/null +++ b/js/src/tests/non262/syntax/syntax-parsed-arrow-then-sourcemap-directive.js @@ -0,0 +1,63 @@ +// |reftest| skip-if(!xulRuntime.shell) -- needs Debugger +/* + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/licenses/publicdomain/ + */ + +//----------------------------------------------------------------------------- +var BUGNUMBER = 1596706; +var summary = + "Properly apply a source map directive that's only tokenized by a syntax " + + "parser (because the directive comment appears immediately after an arrow " + + "function with expression body)"; + +print(BUGNUMBER + ": " + summary); + +/************** + * BEGIN TEST * + **************/ + +var g = newGlobal({newCompartment: true}); +var dbg = new Debugger(g); + +var script; +dbg.onDebuggerStatement = function (frame) +{ + script = frame.script; +}; + +function checkSourceMapFor(arrowFunc, sourceMap) +{ + g.evaluate(`${arrowFunc} +//# sourceMappingURL=${sourceMap} +debugger;`); + + assertEq(script instanceof Debugger.Script, true, + "expected a Debugger.Script for " + arrowFunc); + + var source = script.source; + assertEq(source instanceof Debugger.Source, true, + "expected a Debugger.Source for " + arrowFunc); + + assertEq(source.sourceMapURL, sourceMap, + "unexpected source map for " + arrowFunc); +} + +// block followed by semicolon +checkSourceMapFor("x=>{};", "http://example.com/foo.js"); + +// block not followed by semicolon +checkSourceMapFor("x=>{}", "http://example.com/bar.js"); + +// expr followed by semicolon +checkSourceMapFor("x=>y;", "http://example.com/baz.js"); + +// expr not followed by semicolon +checkSourceMapFor("x=>y", "http://example.com/bar.js"); + +/******************************************************************************/ + +if (typeof reportCompare === "function") + reportCompare(true, true); + +print("Tests complete"); diff --git a/js/src/tests/non262/syntax/unicode_other_id_continue.js b/js/src/tests/non262/syntax/unicode_other_id_continue.js new file mode 100644 index 0000000000..03dd09b71b --- /dev/null +++ b/js/src/tests/non262/syntax/unicode_other_id_continue.js @@ -0,0 +1,45 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +// From PropList.txt (Unicode 9): +const otherIdContinue = [ + 0x00B7, // MIDDLE DOT, Gc=Po + 0x0387, // GREEK ANO TELEIA, Gc=Po + 0x1369, // ETHIOPIC DIGIT ONE, Gc=No + 0x136A, // ETHIOPIC DIGIT TWO, Gc=No + 0x136B, // ETHIOPIC DIGIT THREE, Gc=No + 0x136C, // ETHIOPIC DIGIT FOUR, Gc=No + 0x136D, // ETHIOPIC DIGIT FIVE, Gc=No + 0x136E, // ETHIOPIC DIGIT SIX, Gc=No + 0x136F, // ETHIOPIC DIGIT SEVEN, Gc=No + 0x1370, // ETHIOPIC DIGIT EIGHT, Gc=No + 0x1371, // ETHIOPIC DIGIT NINE, Gc=No + 0x19DA, // NEW TAI LUE THAM DIGIT ONE, Gc=No +]; + +// Leading character in identifier. +for (let ident of [...otherIdContinue]) { + assertThrowsInstanceOf(() => eval(`${String.fromCodePoint(ident)}`), SyntaxError); + assertThrowsInstanceOf(() => eval(`\\u${ident.toString(16).padStart(4, "0")}`), SyntaxError); + assertThrowsInstanceOf(() => eval(`\\u{${ident.toString(16)}}`), SyntaxError); +} + +// Not leading character in identifier. +for (let ident of [...otherIdContinue]) { + eval(` + let A${String.fromCodePoint(ident)} = 123; + assertEq(${String.fromCodePoint(0x41, ident)}, 123); + `); + eval(` + let A\\u${ident.toString(16).padStart(4, "0")} = 123; + assertEq(${String.fromCodePoint(0x41, ident)}, 123); + `); + eval(` + let A\\u{${ident.toString(16)}} = 123; + assertEq(${String.fromCodePoint(0x41, ident)}, 123); + `); +} + +if (typeof reportCompare === "function") + reportCompare(0, 0, "ok"); diff --git a/js/src/tests/non262/syntax/unicode_other_id_start.js b/js/src/tests/non262/syntax/unicode_other_id_start.js new file mode 100644 index 0000000000..86790dd00e --- /dev/null +++ b/js/src/tests/non262/syntax/unicode_other_id_start.js @@ -0,0 +1,48 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +// From PropList.txt (Unicode 9): +const otherIdStart = [ + 0x1885, // MONGOLIAN LETTER ALI GALI BALUDA, Gc=Mn + 0x1886, // MONGOLIAN LETTER ALI GALI THREE BALUDA, Gc=Mn + 0x2118, // SCRIPT CAPITAL P, Gc=Sm + 0x212E, // ESTIMATED SYMBOL, Gc=So + 0x309B, // KATAKANA-HIRAGANA VOICED SOUND MARK, Gc=Sk + 0x309C, // KATAKANA-HIRAGANA SEMI-VOICED SOUND MARK, Gc=Sk +]; + +// Leading character in identifier. +for (let ident of otherIdStart) { + eval(` + let ${String.fromCodePoint(ident)} = 123; + assertEq(${String.fromCodePoint(ident)}, 123); + `); + eval(` + let \\u${ident.toString(16).padStart(4, "0")} = 123; + assertEq(${String.fromCodePoint(ident)}, 123); + `); + eval(` + let \\u{${ident.toString(16)}} = 123; + assertEq(${String.fromCodePoint(ident)}, 123); + `); +} + +// Not leading character in identifier. +for (let ident of otherIdStart) { + eval(` + let A${String.fromCodePoint(ident)} = 123; + assertEq(${String.fromCodePoint(0x41, ident)}, 123); + `); + eval(` + let A\\u${ident.toString(16).padStart(4, "0")} = 123; + assertEq(${String.fromCodePoint(0x41, ident)}, 123); + `); + eval(` + let A\\u{${ident.toString(16)}} = 123; + assertEq(${String.fromCodePoint(0x41, ident)}, 123); + `); +} + +if (typeof reportCompare === "function") + reportCompare(0, 0, "ok"); diff --git a/js/src/tests/non262/syntax/yield-as-identifier.js b/js/src/tests/non262/syntax/yield-as-identifier.js new file mode 100644 index 0000000000..665b0b11c4 --- /dev/null +++ b/js/src/tests/non262/syntax/yield-as-identifier.js @@ -0,0 +1,54 @@ +/* + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/licenses/publicdomain/ + */ + +//----------------------------------------------------------------------------- +var BUGNUMBER = 1288459; +var summary = "|yield| is sometimes a valid identifier"; + +print(BUGNUMBER + ": " + summary); + +/************** + * BEGIN TEST * + **************/ + +function t(code) +{ + var strictSemi = " 'use strict'; " + code; + var strictASI = " 'use strict' \n " + code; + + var creationFunctions = ["Function"]; + if (typeof evaluate === "function") + creationFunctions.push("evaluate"); + if (typeof parseModule === "function") + creationFunctions.push("parseModule"); + + for (var func of creationFunctions) + { + var g = newGlobal(); + var f = g[func]; + + if (func === "parseModule") + assertThrowsInstanceOf(() => f(code), g.SyntaxError); + else + f(code); + + assertThrowsInstanceOf(() => f(strictSemi), g.SyntaxError); + assertThrowsInstanceOf(() => f(strictASI), g.SyntaxError); + } +} + +t("var yield = 3;"); +t("let yield = 3;"); +t("const yield = 3;"); +t("for (var yield = 3; ; ) break;"); +t("for (let yield = 3; ; ) break;"); +t("for (const yield = 3; ; ) break;"); + +/******************************************************************************/ + +if (typeof reportCompare === "function") + reportCompare(true, true); + +print("Tests complete"); |