Stowage/ladybird
2
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-10-21 00:23:20 +00:00
Code Issues Projects Releases Packages Wiki Activity
ladybird/Libraries/LibJS/Tests/syntax/slash-after-block.js

68 lines
2.4 KiB
JavaScript
Raw Normal View History

LibJS: Make a slash after a curly close mean not-division There's no grammar rule that allows this.
2021-07-02 14:46:58 +04:30
test("slash token resolution in lexer", () => {
expect(`{ blah.blah; }\n/foo/`).toEval();
LibJS: Allow division after IdentifierNames in optional chain The following syntax is valid: ```js e?.example / 1.2 ``` Previously, the `/` would be treated as a unterminated regex literal, because it was calling the regular `consume` instead of `consume_and_allow_division`. This is what is done when parsing IdentifierNames in parse_secondary_expression when a period is encountered. Allows us to parse clients-main-[hash].js on https://ubereats.com/
2024-11-11 16:47:53 +00:00
expect(`{ blah?.blah.blah; }\n/foo/`).toEval();
LibJS: Make a slash after a curly close mean not-division There's no grammar rule that allows this.
2021-07-02 14:46:58 +04:30
expect("``/foo/").not.toEval();
expect("1/foo/").not.toEval();
expect("1/foo").toEval();
LibJS: Force the lexer to parse a regex when expecting a statement
2021-07-29 23:28:28 +02:00
expect("{} /foo/").toEval();
expect("{} /=/").toEval();
expect("{} /=a/").toEval();
expect("{} /* */ /=a/").toEval();
expect("{} /* /a/ */ /=a/").toEval();
expect("(function () {} / 1)").toEval();
expect("(function () {} / 1)").toEval();
expect("+a++ / 1").toEval();
expect("+a-- / 1").toEval();
expect("a.in / b").toEval();
LibJS: Allow division after IdentifierNames in optional chain The following syntax is valid: ```js e?.example / 1.2 ``` Previously, the `/` would be treated as a unterminated regex literal, because it was calling the regular `consume` instead of `consume_and_allow_division`. This is what is done when parsing IdentifierNames in parse_secondary_expression when a period is encountered. Allows us to parse clients-main-[hash].js on https://ubereats.com/
2024-11-11 16:47:53 +00:00
expect("a?.in.in / b").toEval();
LibJS: Force the lexer to parse a regex when expecting a statement
2021-07-29 23:28:28 +02:00
expect("a.instanceof / b").toEval();
LibJS: Allow division after IdentifierNames in optional chain The following syntax is valid: ```js e?.example / 1.2 ``` Previously, the `/` would be treated as a unterminated regex literal, because it was calling the regular `consume` instead of `consume_and_allow_division`. This is what is done when parsing IdentifierNames in parse_secondary_expression when a period is encountered. Allows us to parse clients-main-[hash].js on https://ubereats.com/
2024-11-11 16:47:53 +00:00
expect("a?.instanceof.instanceof / b").toEval();
LibJS: Treat private identifier as divisible token And also make sure private identifiers are correctly checked when synthesizing a binding pattern.
2021-11-26 21:10:24 +01:00
expect("class A { #name; d = a.#name / b; }").toEval();
LibJS: Allow division after IdentifierNames in optional chain The following syntax is valid: ```js e?.example / 1.2 ``` Previously, the `/` would be treated as a unterminated regex literal, because it was calling the regular `consume` instead of `consume_and_allow_division`. This is what is done when parsing IdentifierNames in parse_secondary_expression when a period is encountered. Allows us to parse clients-main-[hash].js on https://ubereats.com/
2024-11-11 16:47:53 +00:00
expect("class A { #name; d = a?.#name / b; }").toEval();
LibJS: Force the lexer to parse a regex when expecting a statement
2021-07-29 23:28:28 +02:00
LibJS: Parse slashes after reserved identifiers correctly Previously we were unable to parse code like `yield/2` because `/2` was parsed as a regex. At the same time `for (a in / b/)` was parsed as a division. This is solved by defaulting to division in the lexer, but calling `force_slash_as_regex()` from the parser whenever an IdentifierName is parsed as a ReservedWord.
2023-05-28 00:08:52 +02:00
expect("async / b").toEval();
expect("a.delete / b").toEval();
LibJS: Allow division after IdentifierNames in optional chain The following syntax is valid: ```js e?.example / 1.2 ``` Previously, the `/` would be treated as a unterminated regex literal, because it was calling the regular `consume` instead of `consume_and_allow_division`. This is what is done when parsing IdentifierNames in parse_secondary_expression when a period is encountered. Allows us to parse clients-main-[hash].js on https://ubereats.com/
2024-11-11 16:47:53 +00:00
expect("a?.delete.delete / b").toEval();
LibJS: Parse slashes after reserved identifiers correctly Previously we were unable to parse code like `yield/2` because `/2` was parsed as a regex. At the same time `for (a in / b/)` was parsed as a division. This is solved by defaulting to division in the lexer, but calling `force_slash_as_regex()` from the parser whenever an IdentifierName is parsed as a ReservedWord.
2023-05-28 00:08:52 +02:00
expect("delete / b/").toEval();
expect("a.in / b").toEval();
LibJS: Allow division after IdentifierNames in optional chain The following syntax is valid: ```js e?.example / 1.2 ``` Previously, the `/` would be treated as a unterminated regex literal, because it was calling the regular `consume` instead of `consume_and_allow_division`. This is what is done when parsing IdentifierNames in parse_secondary_expression when a period is encountered. Allows us to parse clients-main-[hash].js on https://ubereats.com/
2024-11-11 16:47:53 +00:00
expect("a?.in.in / b").toEval();
LibJS: Parse slashes after reserved identifiers correctly Previously we were unable to parse code like `yield/2` because `/2` was parsed as a regex. At the same time `for (a in / b/)` was parsed as a division. This is solved by defaulting to division in the lexer, but calling `force_slash_as_regex()` from the parser whenever an IdentifierName is parsed as a ReservedWord.
2023-05-28 00:08:52 +02:00
expect("for (a in / b/) {}").toEval();
expect("a.instanceof / b").toEval();
LibJS: Allow division after IdentifierNames in optional chain The following syntax is valid: ```js e?.example / 1.2 ``` Previously, the `/` would be treated as a unterminated regex literal, because it was calling the regular `consume` instead of `consume_and_allow_division`. This is what is done when parsing IdentifierNames in parse_secondary_expression when a period is encountered. Allows us to parse clients-main-[hash].js on https://ubereats.com/
2024-11-11 16:47:53 +00:00
expect("a?.instanceof.instanceof / b").toEval();
LibJS: Parse slashes after reserved identifiers correctly Previously we were unable to parse code like `yield/2` because `/2` was parsed as a regex. At the same time `for (a in / b/)` was parsed as a division. This is solved by defaulting to division in the lexer, but calling `force_slash_as_regex()` from the parser whenever an IdentifierName is parsed as a ReservedWord.
2023-05-28 00:08:52 +02:00
expect("a instanceof / b/").toEval();
LibJS: Allow division after IdentifierNames in optional chain The following syntax is valid: ```js e?.example / 1.2 ``` Previously, the `/` would be treated as a unterminated regex literal, because it was calling the regular `consume` instead of `consume_and_allow_division`. This is what is done when parsing IdentifierNames in parse_secondary_expression when a period is encountered. Allows us to parse clients-main-[hash].js on https://ubereats.com/
2024-11-11 16:47:53 +00:00
expect("a?.instanceof instanceof / b/").toEval();
LibJS: Parse slashes after reserved identifiers correctly Previously we were unable to parse code like `yield/2` because `/2` was parsed as a regex. At the same time `for (a in / b/)` was parsed as a division. This is solved by defaulting to division in the lexer, but calling `force_slash_as_regex()` from the parser whenever an IdentifierName is parsed as a ReservedWord.
2023-05-28 00:08:52 +02:00
expect("new / b/").toEval();
expect("null / b").toEval();
expect("for (a of / b/) {}").toEval();
expect("a.return / b").toEval();
LibJS: Allow division after IdentifierNames in optional chain The following syntax is valid: ```js e?.example / 1.2 ``` Previously, the `/` would be treated as a unterminated regex literal, because it was calling the regular `consume` instead of `consume_and_allow_division`. This is what is done when parsing IdentifierNames in parse_secondary_expression when a period is encountered. Allows us to parse clients-main-[hash].js on https://ubereats.com/
2024-11-11 16:47:53 +00:00
expect("a?.return.return / b").toEval();
LibJS: Parse slashes after reserved identifiers correctly Previously we were unable to parse code like `yield/2` because `/2` was parsed as a regex. At the same time `for (a in / b/)` was parsed as a division. This is solved by defaulting to division in the lexer, but calling `force_slash_as_regex()` from the parser whenever an IdentifierName is parsed as a ReservedWord.
2023-05-28 00:08:52 +02:00
expect("function foo() { return / b/ }").toEval();
expect("throw / b/").toEval();
expect("a.typeof / b").toEval();
LibJS: Allow division after IdentifierNames in optional chain The following syntax is valid: ```js e?.example / 1.2 ``` Previously, the `/` would be treated as a unterminated regex literal, because it was calling the regular `consume` instead of `consume_and_allow_division`. This is what is done when parsing IdentifierNames in parse_secondary_expression when a period is encountered. Allows us to parse clients-main-[hash].js on https://ubereats.com/
2024-11-11 16:47:53 +00:00
expect("a?.typeof.typeof / b").toEval();
LibJS: Parse slashes after reserved identifiers correctly Previously we were unable to parse code like `yield/2` because `/2` was parsed as a regex. At the same time `for (a in / b/)` was parsed as a division. This is solved by defaulting to division in the lexer, but calling `force_slash_as_regex()` from the parser whenever an IdentifierName is parsed as a ReservedWord.
2023-05-28 00:08:52 +02:00
expect("a.void / b").toEval();
LibJS: Allow division after IdentifierNames in optional chain The following syntax is valid: ```js e?.example / 1.2 ``` Previously, the `/` would be treated as a unterminated regex literal, because it was calling the regular `consume` instead of `consume_and_allow_division`. This is what is done when parsing IdentifierNames in parse_secondary_expression when a period is encountered. Allows us to parse clients-main-[hash].js on https://ubereats.com/
2024-11-11 16:47:53 +00:00
expect("a?.void.void / b").toEval();
LibJS: Force the lexer to parse a regex when expecting a statement
2021-07-29 23:28:28 +02:00
expect("void / b/").toEval();
LibJS: Parse slashes after reserved identifiers correctly Previously we were unable to parse code like `yield/2` because `/2` was parsed as a regex. At the same time `for (a in / b/)` was parsed as a division. This is solved by defaulting to division in the lexer, but calling `force_slash_as_regex()` from the parser whenever an IdentifierName is parsed as a ReservedWord.
2023-05-28 00:08:52 +02:00
expect("await / b").toEval();
expect("await / b/").not.toEval();
expect("async function foo() { await / b }").not.toEval();
expect("async function foo() { await / b/ }").toEval();
expect("yield / b").toEval();
expect("yield / b/").not.toEval();
expect("function* foo() { yield / b }").not.toEval();
expect("function* foo() { yield / b/ }").toEval();
LibJS: Allow division after `this` token This fixes the root cause of #21747, so it makes the clock work on https://toaruos.org
2023-11-04 20:40:12 +01:00
expect("this / 1").toEval();
expect("this / 1 /").not.toEval();
expect("this / 1 / 1").toEval();
LibJS: Allow division after IdentifierNames in optional chain The following syntax is valid: ```js e?.example / 1.2 ``` Previously, the `/` would be treated as a unterminated regex literal, because it was calling the regular `consume` instead of `consume_and_allow_division`. This is what is done when parsing IdentifierNames in parse_secondary_expression when a period is encountered. Allows us to parse clients-main-[hash].js on https://ubereats.com/
2024-11-11 16:47:53 +00:00
expect("this?.a / 1").toEval();
expect("this?.a / 1 /").not.toEval();
expect("this?.a / 1 / 1").toEval();
LibJS: Make a slash after a curly close mean not-division There's no grammar rule that allows this.
2021-07-02 14:46:58 +04:30
});
Reference in a new issue Copy permalink