Parser.cpp 61 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633
  1. /*
  2. * Copyright (c) 2020, Stephan Unverwerth <s.unverwerth@gmx.de>
  3. * Copyright (c) 2020, Linus Groh <mail@linusgroh.de>
  4. * All rights reserved.
  5. *
  6. * Redistribution and use in source and binary forms, with or without
  7. * modification, are permitted provided that the following conditions are met:
  8. *
  9. * 1. Redistributions of source code must retain the above copyright notice, this
  10. * list of conditions and the following disclaimer.
  11. *
  12. * 2. Redistributions in binary form must reproduce the above copyright notice,
  13. * this list of conditions and the following disclaimer in the documentation
  14. * and/or other materials provided with the distribution.
  15. *
  16. * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  17. * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18. * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  19. * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
  20. * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21. * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  22. * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  23. * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  24. * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  25. * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26. */
  27. #include "Parser.h"
  28. #include <AK/HashMap.h>
  29. #include <AK/ScopeGuard.h>
  30. #include <AK/StdLibExtras.h>
  31. namespace JS {
  32. class ScopePusher {
  33. public:
  34. enum Type {
  35. Var = 1,
  36. Let = 2,
  37. Function = 3,
  38. };
  39. ScopePusher(Parser& parser, unsigned mask)
  40. : m_parser(parser)
  41. , m_mask(mask)
  42. {
  43. if (m_mask & Var)
  44. m_parser.m_parser_state.m_var_scopes.append(NonnullRefPtrVector<VariableDeclaration>());
  45. if (m_mask & Let)
  46. m_parser.m_parser_state.m_let_scopes.append(NonnullRefPtrVector<VariableDeclaration>());
  47. if (m_mask & Function)
  48. m_parser.m_parser_state.m_function_scopes.append(NonnullRefPtrVector<FunctionDeclaration>());
  49. }
  50. ~ScopePusher()
  51. {
  52. if (m_mask & Var)
  53. m_parser.m_parser_state.m_var_scopes.take_last();
  54. if (m_mask & Let)
  55. m_parser.m_parser_state.m_let_scopes.take_last();
  56. if (m_mask & Function)
  57. m_parser.m_parser_state.m_function_scopes.take_last();
  58. }
  59. Parser& m_parser;
  60. unsigned m_mask { 0 };
  61. };
  62. static HashMap<TokenType, int> g_operator_precedence;
  63. Parser::ParserState::ParserState(Lexer lexer)
  64. : m_lexer(move(lexer))
  65. , m_current_token(m_lexer.next())
  66. {
  67. }
  68. Parser::Parser(Lexer lexer)
  69. : m_parser_state(move(lexer))
  70. {
  71. if (g_operator_precedence.is_empty()) {
  72. // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence
  73. g_operator_precedence.set(TokenType::Period, 20);
  74. g_operator_precedence.set(TokenType::BracketOpen, 20);
  75. g_operator_precedence.set(TokenType::ParenOpen, 20);
  76. g_operator_precedence.set(TokenType::QuestionMarkPeriod, 20);
  77. g_operator_precedence.set(TokenType::New, 19);
  78. g_operator_precedence.set(TokenType::PlusPlus, 18);
  79. g_operator_precedence.set(TokenType::MinusMinus, 18);
  80. g_operator_precedence.set(TokenType::ExclamationMark, 17);
  81. g_operator_precedence.set(TokenType::Tilde, 17);
  82. g_operator_precedence.set(TokenType::Typeof, 17);
  83. g_operator_precedence.set(TokenType::Void, 17);
  84. g_operator_precedence.set(TokenType::Delete, 17);
  85. g_operator_precedence.set(TokenType::Await, 17);
  86. g_operator_precedence.set(TokenType::DoubleAsterisk, 16);
  87. g_operator_precedence.set(TokenType::Asterisk, 15);
  88. g_operator_precedence.set(TokenType::Slash, 15);
  89. g_operator_precedence.set(TokenType::Percent, 15);
  90. g_operator_precedence.set(TokenType::Plus, 14);
  91. g_operator_precedence.set(TokenType::Minus, 14);
  92. g_operator_precedence.set(TokenType::ShiftLeft, 13);
  93. g_operator_precedence.set(TokenType::ShiftRight, 13);
  94. g_operator_precedence.set(TokenType::UnsignedShiftRight, 13);
  95. g_operator_precedence.set(TokenType::LessThan, 12);
  96. g_operator_precedence.set(TokenType::LessThanEquals, 12);
  97. g_operator_precedence.set(TokenType::GreaterThan, 12);
  98. g_operator_precedence.set(TokenType::GreaterThanEquals, 12);
  99. g_operator_precedence.set(TokenType::In, 12);
  100. g_operator_precedence.set(TokenType::Instanceof, 12);
  101. g_operator_precedence.set(TokenType::EqualsEquals, 11);
  102. g_operator_precedence.set(TokenType::ExclamationMarkEquals, 11);
  103. g_operator_precedence.set(TokenType::EqualsEqualsEquals, 11);
  104. g_operator_precedence.set(TokenType::ExclamationMarkEqualsEquals, 11);
  105. g_operator_precedence.set(TokenType::Ampersand, 10);
  106. g_operator_precedence.set(TokenType::Caret, 9);
  107. g_operator_precedence.set(TokenType::Pipe, 8);
  108. g_operator_precedence.set(TokenType::DoubleQuestionMark, 7);
  109. g_operator_precedence.set(TokenType::DoubleAmpersand, 6);
  110. g_operator_precedence.set(TokenType::DoublePipe, 5);
  111. g_operator_precedence.set(TokenType::QuestionMark, 4);
  112. g_operator_precedence.set(TokenType::Equals, 3);
  113. g_operator_precedence.set(TokenType::PlusEquals, 3);
  114. g_operator_precedence.set(TokenType::MinusEquals, 3);
  115. g_operator_precedence.set(TokenType::DoubleAsteriskEquals, 3);
  116. g_operator_precedence.set(TokenType::AsteriskEquals, 3);
  117. g_operator_precedence.set(TokenType::SlashEquals, 3);
  118. g_operator_precedence.set(TokenType::PercentEquals, 3);
  119. g_operator_precedence.set(TokenType::ShiftLeftEquals, 3);
  120. g_operator_precedence.set(TokenType::ShiftRightEquals, 3);
  121. g_operator_precedence.set(TokenType::UnsignedShiftRightEquals, 3);
  122. g_operator_precedence.set(TokenType::AmpersandEquals, 3);
  123. g_operator_precedence.set(TokenType::PipeEquals, 3);
  124. g_operator_precedence.set(TokenType::CaretEquals, 3);
  125. g_operator_precedence.set(TokenType::Yield, 2);
  126. g_operator_precedence.set(TokenType::Comma, 1);
  127. }
  128. }
  129. int Parser::operator_precedence(TokenType type) const
  130. {
  131. auto it = g_operator_precedence.find(type);
  132. if (it == g_operator_precedence.end()) {
  133. fprintf(stderr, "Internal Error: No precedence for operator %s\n", Token::name(type));
  134. ASSERT_NOT_REACHED();
  135. return -1;
  136. }
  137. return it->value;
  138. }
  139. Associativity Parser::operator_associativity(TokenType type) const
  140. {
  141. switch (type) {
  142. case TokenType::Period:
  143. case TokenType::BracketOpen:
  144. case TokenType::ParenOpen:
  145. case TokenType::QuestionMarkPeriod:
  146. case TokenType::Asterisk:
  147. case TokenType::Slash:
  148. case TokenType::Percent:
  149. case TokenType::Plus:
  150. case TokenType::Minus:
  151. case TokenType::ShiftLeft:
  152. case TokenType::ShiftRight:
  153. case TokenType::UnsignedShiftRight:
  154. case TokenType::LessThan:
  155. case TokenType::LessThanEquals:
  156. case TokenType::GreaterThan:
  157. case TokenType::GreaterThanEquals:
  158. case TokenType::In:
  159. case TokenType::Instanceof:
  160. case TokenType::EqualsEquals:
  161. case TokenType::ExclamationMarkEquals:
  162. case TokenType::EqualsEqualsEquals:
  163. case TokenType::ExclamationMarkEqualsEquals:
  164. case TokenType::Typeof:
  165. case TokenType::Void:
  166. case TokenType::Delete:
  167. case TokenType::Ampersand:
  168. case TokenType::Caret:
  169. case TokenType::Pipe:
  170. case TokenType::DoubleQuestionMark:
  171. case TokenType::DoubleAmpersand:
  172. case TokenType::DoublePipe:
  173. case TokenType::Comma:
  174. return Associativity::Left;
  175. default:
  176. return Associativity::Right;
  177. }
  178. }
  179. NonnullRefPtr<Program> Parser::parse_program()
  180. {
  181. ScopePusher scope(*this, ScopePusher::Var | ScopePusher::Let | ScopePusher::Function);
  182. auto program = adopt(*new Program);
  183. bool first = true;
  184. m_parser_state.m_use_strict_directive = UseStrictDirectiveState::Looking;
  185. while (!done()) {
  186. if (match_statement()) {
  187. program->append(parse_statement());
  188. if (first) {
  189. if (m_parser_state.m_use_strict_directive == UseStrictDirectiveState::Found) {
  190. program->set_strict_mode();
  191. m_parser_state.m_strict_mode = true;
  192. }
  193. first = false;
  194. m_parser_state.m_use_strict_directive = UseStrictDirectiveState::None;
  195. }
  196. } else {
  197. expected("statement");
  198. consume();
  199. }
  200. }
  201. if (m_parser_state.m_var_scopes.size() == 1) {
  202. program->add_variables(m_parser_state.m_var_scopes.last());
  203. program->add_variables(m_parser_state.m_let_scopes.last());
  204. program->add_functions(m_parser_state.m_function_scopes.last());
  205. } else {
  206. syntax_error("Unclosed scope");
  207. }
  208. return program;
  209. }
  210. NonnullRefPtr<Statement> Parser::parse_statement()
  211. {
  212. auto statement = [this]() -> NonnullRefPtr<Statement> {
  213. switch (m_parser_state.m_current_token.type()) {
  214. case TokenType::Function: {
  215. auto declaration = parse_function_node<FunctionDeclaration>();
  216. m_parser_state.m_function_scopes.last().append(declaration);
  217. return declaration;
  218. }
  219. case TokenType::CurlyOpen:
  220. return parse_block_statement();
  221. case TokenType::Return:
  222. return parse_return_statement();
  223. case TokenType::Var:
  224. case TokenType::Let:
  225. case TokenType::Const:
  226. return parse_variable_declaration();
  227. case TokenType::For:
  228. return parse_for_statement();
  229. case TokenType::If:
  230. return parse_if_statement();
  231. case TokenType::Throw:
  232. return parse_throw_statement();
  233. case TokenType::Try:
  234. return parse_try_statement();
  235. case TokenType::Break:
  236. return parse_break_statement();
  237. case TokenType::Continue:
  238. return parse_continue_statement();
  239. case TokenType::Switch:
  240. return parse_switch_statement();
  241. case TokenType::Do:
  242. return parse_do_while_statement();
  243. case TokenType::While:
  244. return parse_while_statement();
  245. case TokenType::Debugger:
  246. return parse_debugger_statement();
  247. case TokenType::Semicolon:
  248. consume();
  249. return create_ast_node<EmptyStatement>();
  250. default:
  251. if (match(TokenType::Identifier)) {
  252. auto result = try_parse_labelled_statement();
  253. if (!result.is_null())
  254. return result.release_nonnull();
  255. }
  256. if (match_expression()) {
  257. auto expr = parse_expression(0);
  258. consume_or_insert_semicolon();
  259. return create_ast_node<ExpressionStatement>(move(expr));
  260. }
  261. expected("statement (missing switch case)");
  262. consume();
  263. return create_ast_node<ErrorStatement>();
  264. } }();
  265. return statement;
  266. }
  267. RefPtr<FunctionExpression> Parser::try_parse_arrow_function_expression(bool expect_parens)
  268. {
  269. save_state();
  270. m_parser_state.m_var_scopes.append(NonnullRefPtrVector<VariableDeclaration>());
  271. ArmedScopeGuard state_rollback_guard = [&] {
  272. m_parser_state.m_var_scopes.take_last();
  273. load_state();
  274. };
  275. Vector<FunctionNode::Parameter> parameters;
  276. bool parse_failed = false;
  277. bool has_rest_parameter = false;
  278. i32 function_length = -1;
  279. while (true) {
  280. if (match(TokenType::Comma)) {
  281. if (has_rest_parameter || !expect_parens) {
  282. parse_failed = true;
  283. break;
  284. }
  285. consume(TokenType::Comma);
  286. } else if (match(TokenType::Identifier)) {
  287. auto parameter_name = consume(TokenType::Identifier).value();
  288. RefPtr<Expression> default_value;
  289. if (expect_parens && match(TokenType::Equals)) {
  290. consume(TokenType::Equals);
  291. function_length = parameters.size();
  292. default_value = parse_expression(2);
  293. }
  294. parameters.append({ parameter_name, default_value });
  295. } else if (match(TokenType::TripleDot)) {
  296. consume();
  297. if (has_rest_parameter) {
  298. parse_failed = true;
  299. break;
  300. }
  301. has_rest_parameter = true;
  302. function_length = parameters.size();
  303. auto parameter_name = consume(TokenType::Identifier).value();
  304. parameters.append({ parameter_name, nullptr, true });
  305. } else if (match(TokenType::ParenClose)) {
  306. if (expect_parens) {
  307. consume(TokenType::ParenClose);
  308. if (match(TokenType::Arrow)) {
  309. consume(TokenType::Arrow);
  310. } else {
  311. parse_failed = true;
  312. }
  313. break;
  314. }
  315. parse_failed = true;
  316. break;
  317. } else if (match(TokenType::Arrow)) {
  318. if (!expect_parens) {
  319. consume(TokenType::Arrow);
  320. break;
  321. }
  322. parse_failed = true;
  323. break;
  324. } else {
  325. parse_failed = true;
  326. break;
  327. }
  328. }
  329. if (parse_failed)
  330. return nullptr;
  331. if (function_length == -1)
  332. function_length = parameters.size();
  333. auto function_body_result = [this]() -> RefPtr<BlockStatement> {
  334. if (match(TokenType::CurlyOpen)) {
  335. // Parse a function body with statements
  336. return parse_block_statement();
  337. }
  338. if (match_expression()) {
  339. // Parse a function body which returns a single expression
  340. // FIXME: We synthesize a block with a return statement
  341. // for arrow function bodies which are a single expression.
  342. // Esprima generates a single "ArrowFunctionExpression"
  343. // with a "body" property.
  344. auto return_expression = parse_expression(2);
  345. auto return_block = create_ast_node<BlockStatement>();
  346. return_block->append<ReturnStatement>(move(return_expression));
  347. return return_block;
  348. }
  349. // Invalid arrow function body
  350. return nullptr;
  351. }();
  352. if (!function_body_result.is_null()) {
  353. state_rollback_guard.disarm();
  354. auto body = function_body_result.release_nonnull();
  355. return create_ast_node<FunctionExpression>("", move(body), move(parameters), function_length, m_parser_state.m_var_scopes.take_last(), true);
  356. }
  357. return nullptr;
  358. }
  359. RefPtr<Statement> Parser::try_parse_labelled_statement()
  360. {
  361. save_state();
  362. ArmedScopeGuard state_rollback_guard = [&] {
  363. load_state();
  364. };
  365. auto identifier = consume(TokenType::Identifier).value();
  366. if (!match(TokenType::Colon))
  367. return {};
  368. consume(TokenType::Colon);
  369. if (!match_statement())
  370. return {};
  371. auto statement = parse_statement();
  372. statement->set_label(identifier);
  373. state_rollback_guard.disarm();
  374. return statement;
  375. }
  376. NonnullRefPtr<Expression> Parser::parse_primary_expression()
  377. {
  378. if (match_unary_prefixed_expression())
  379. return parse_unary_prefixed_expression();
  380. switch (m_parser_state.m_current_token.type()) {
  381. case TokenType::ParenOpen: {
  382. consume(TokenType::ParenOpen);
  383. if (match(TokenType::ParenClose) || match(TokenType::Identifier) || match(TokenType::TripleDot)) {
  384. auto arrow_function_result = try_parse_arrow_function_expression(true);
  385. if (!arrow_function_result.is_null()) {
  386. return arrow_function_result.release_nonnull();
  387. }
  388. }
  389. auto expression = parse_expression(0);
  390. consume(TokenType::ParenClose);
  391. return expression;
  392. }
  393. case TokenType::This:
  394. consume();
  395. return create_ast_node<ThisExpression>();
  396. case TokenType::Identifier: {
  397. auto arrow_function_result = try_parse_arrow_function_expression(false);
  398. if (!arrow_function_result.is_null()) {
  399. return arrow_function_result.release_nonnull();
  400. }
  401. return create_ast_node<Identifier>(consume().value());
  402. }
  403. case TokenType::NumericLiteral:
  404. return create_ast_node<NumericLiteral>(consume().double_value());
  405. case TokenType::BigIntLiteral:
  406. return create_ast_node<BigIntLiteral>(consume().value());
  407. case TokenType::BoolLiteral:
  408. return create_ast_node<BooleanLiteral>(consume().bool_value());
  409. case TokenType::StringLiteral:
  410. return parse_string_literal(consume());
  411. case TokenType::NullLiteral:
  412. consume();
  413. return create_ast_node<NullLiteral>();
  414. case TokenType::CurlyOpen:
  415. return parse_object_expression();
  416. case TokenType::Function:
  417. return parse_function_node<FunctionExpression>();
  418. case TokenType::BracketOpen:
  419. return parse_array_expression();
  420. case TokenType::RegexLiteral:
  421. return parse_regexp_literal();
  422. case TokenType::TemplateLiteralStart:
  423. return parse_template_literal(false);
  424. case TokenType::New:
  425. return parse_new_expression();
  426. default:
  427. expected("primary expression (missing switch case)");
  428. consume();
  429. return create_ast_node<ErrorExpression>();
  430. }
  431. }
  432. NonnullRefPtr<RegExpLiteral> Parser::parse_regexp_literal()
  433. {
  434. auto content = consume().value();
  435. auto flags = match(TokenType::RegexFlags) ? consume().value() : "";
  436. return create_ast_node<RegExpLiteral>(content.substring_view(1, content.length() - 2), flags);
  437. }
  438. NonnullRefPtr<Expression> Parser::parse_unary_prefixed_expression()
  439. {
  440. auto precedence = operator_precedence(m_parser_state.m_current_token.type());
  441. auto associativity = operator_associativity(m_parser_state.m_current_token.type());
  442. switch (m_parser_state.m_current_token.type()) {
  443. case TokenType::PlusPlus: {
  444. consume();
  445. auto rhs_start_line = m_parser_state.m_current_token.line_number();
  446. auto rhs_start_column = m_parser_state.m_current_token.line_column();
  447. auto rhs = parse_expression(precedence, associativity);
  448. if (!rhs->is_identifier() && !rhs->is_member_expression())
  449. syntax_error(String::format("Right-hand side of prefix increment operator must be identifier or member expression, got %s", rhs->class_name()), rhs_start_line, rhs_start_column);
  450. return create_ast_node<UpdateExpression>(UpdateOp::Increment, move(rhs), true);
  451. }
  452. case TokenType::MinusMinus: {
  453. consume();
  454. auto rhs_start_line = m_parser_state.m_current_token.line_number();
  455. auto rhs_start_column = m_parser_state.m_current_token.line_column();
  456. auto rhs = parse_expression(precedence, associativity);
  457. if (!rhs->is_identifier() && !rhs->is_member_expression())
  458. syntax_error(String::format("Right-hand side of prefix decrement operator must be identifier or member expression, got %s", rhs->class_name()), rhs_start_line, rhs_start_column);
  459. return create_ast_node<UpdateExpression>(UpdateOp::Decrement, move(rhs), true);
  460. }
  461. case TokenType::ExclamationMark:
  462. consume();
  463. return create_ast_node<UnaryExpression>(UnaryOp::Not, parse_expression(precedence, associativity));
  464. case TokenType::Tilde:
  465. consume();
  466. return create_ast_node<UnaryExpression>(UnaryOp::BitwiseNot, parse_expression(precedence, associativity));
  467. case TokenType::Plus:
  468. consume();
  469. return create_ast_node<UnaryExpression>(UnaryOp::Plus, parse_expression(precedence, associativity));
  470. case TokenType::Minus:
  471. consume();
  472. return create_ast_node<UnaryExpression>(UnaryOp::Minus, parse_expression(precedence, associativity));
  473. case TokenType::Typeof:
  474. consume();
  475. return create_ast_node<UnaryExpression>(UnaryOp::Typeof, parse_expression(precedence, associativity));
  476. case TokenType::Void:
  477. consume();
  478. return create_ast_node<UnaryExpression>(UnaryOp::Void, parse_expression(precedence, associativity));
  479. case TokenType::Delete:
  480. consume();
  481. return create_ast_node<UnaryExpression>(UnaryOp::Delete, parse_expression(precedence, associativity));
  482. default:
  483. expected("primary expression (missing switch case)");
  484. consume();
  485. return create_ast_node<ErrorExpression>();
  486. }
  487. }
  488. NonnullRefPtr<ObjectExpression> Parser::parse_object_expression()
  489. {
  490. consume(TokenType::CurlyOpen);
  491. NonnullRefPtrVector<ObjectProperty> properties;
  492. ObjectProperty::Type property_type;
  493. auto match_property_key = [&]() -> bool {
  494. auto type = m_parser_state.m_current_token.type();
  495. return match_identifier_name()
  496. || type == TokenType::BracketOpen
  497. || type == TokenType::StringLiteral
  498. || type == TokenType::NumericLiteral
  499. || type == TokenType::BigIntLiteral;
  500. };
  501. auto parse_property_key = [&]() -> NonnullRefPtr<Expression> {
  502. if (match(TokenType::StringLiteral)) {
  503. return parse_string_literal(consume());
  504. } else if (match(TokenType::NumericLiteral)) {
  505. return create_ast_node<StringLiteral>(consume(TokenType::NumericLiteral).value());
  506. } else if (match(TokenType::BigIntLiteral)) {
  507. auto value = consume(TokenType::BigIntLiteral).value();
  508. return create_ast_node<StringLiteral>(value.substring_view(0, value.length() - 1));
  509. } else if (match(TokenType::BracketOpen)) {
  510. consume(TokenType::BracketOpen);
  511. auto result = parse_expression(0);
  512. consume(TokenType::BracketClose);
  513. return result;
  514. } else {
  515. if (!match_identifier_name())
  516. expected("IdentifierName");
  517. return create_ast_node<StringLiteral>(consume().value());
  518. }
  519. };
  520. auto skip_to_next_property = [&] {
  521. while (!done() && !match(TokenType::Comma) && !match(TokenType::CurlyOpen))
  522. consume();
  523. };
  524. while (!done() && !match(TokenType::CurlyClose)) {
  525. property_type = ObjectProperty::Type::KeyValue;
  526. RefPtr<Expression> property_name;
  527. RefPtr<Expression> property_value;
  528. if (match(TokenType::TripleDot)) {
  529. consume();
  530. property_name = parse_expression(4);
  531. properties.append(create_ast_node<ObjectProperty>(*property_name, nullptr, ObjectProperty::Type::Spread));
  532. if (!match(TokenType::Comma))
  533. break;
  534. consume(TokenType::Comma);
  535. continue;
  536. }
  537. if (match(TokenType::Identifier)) {
  538. auto identifier = consume().value();
  539. if (identifier == "get" && match_property_key()) {
  540. property_type = ObjectProperty::Type::Getter;
  541. property_name = parse_property_key();
  542. } else if (identifier == "set" && match_property_key()) {
  543. property_type = ObjectProperty::Type::Setter;
  544. property_name = parse_property_key();
  545. } else {
  546. property_name = create_ast_node<StringLiteral>(identifier);
  547. property_value = create_ast_node<Identifier>(identifier);
  548. }
  549. } else {
  550. property_name = parse_property_key();
  551. }
  552. if (property_type == ObjectProperty::Type::Getter || property_type == ObjectProperty::Type::Setter) {
  553. if (!match(TokenType::ParenOpen)) {
  554. syntax_error(
  555. "Expected '(' for object getter or setter property",
  556. m_parser_state.m_current_token.line_number(),
  557. m_parser_state.m_current_token.line_column());
  558. skip_to_next_property();
  559. continue;
  560. }
  561. }
  562. if (match(TokenType::ParenOpen)) {
  563. ASSERT(property_name);
  564. auto function = parse_function_node<FunctionExpression>(false);
  565. auto arg_count = function->parameters().size();
  566. if (property_type == ObjectProperty::Type::Getter && arg_count != 0) {
  567. syntax_error(
  568. "Object getter property must have no arguments",
  569. m_parser_state.m_current_token.line_number(),
  570. m_parser_state.m_current_token.line_column());
  571. skip_to_next_property();
  572. continue;
  573. }
  574. if (property_type == ObjectProperty::Type::Setter && arg_count != 1) {
  575. syntax_error(
  576. "Object setter property must have one argument",
  577. m_parser_state.m_current_token.line_number(),
  578. m_parser_state.m_current_token.line_column());
  579. skip_to_next_property();
  580. continue;
  581. }
  582. properties.append(create_ast_node<ObjectProperty>(*property_name, function, property_type));
  583. } else if (match(TokenType::Colon)) {
  584. if (!property_name) {
  585. syntax_error("Expected a property name");
  586. skip_to_next_property();
  587. continue;
  588. }
  589. consume();
  590. properties.append(create_ast_node<ObjectProperty>(*property_name, parse_expression(2), property_type));
  591. } else if (property_name && property_value) {
  592. properties.append(create_ast_node<ObjectProperty>(*property_name, *property_value, property_type));
  593. } else {
  594. syntax_error("Expected a property");
  595. skip_to_next_property();
  596. continue;
  597. }
  598. if (!match(TokenType::Comma))
  599. break;
  600. consume(TokenType::Comma);
  601. }
  602. consume(TokenType::CurlyClose);
  603. return create_ast_node<ObjectExpression>(properties);
  604. }
  605. NonnullRefPtr<ArrayExpression> Parser::parse_array_expression()
  606. {
  607. consume(TokenType::BracketOpen);
  608. Vector<RefPtr<Expression>> elements;
  609. while (match_expression() || match(TokenType::TripleDot) || match(TokenType::Comma)) {
  610. RefPtr<Expression> expression;
  611. if (match(TokenType::TripleDot)) {
  612. consume(TokenType::TripleDot);
  613. expression = create_ast_node<SpreadExpression>(parse_expression(2));
  614. } else if (match_expression()) {
  615. expression = parse_expression(2);
  616. }
  617. elements.append(expression);
  618. if (!match(TokenType::Comma))
  619. break;
  620. consume(TokenType::Comma);
  621. }
  622. consume(TokenType::BracketClose);
  623. return create_ast_node<ArrayExpression>(move(elements));
  624. }
  625. NonnullRefPtr<StringLiteral> Parser::parse_string_literal(Token token)
  626. {
  627. auto status = Token::StringValueStatus::Ok;
  628. auto string = token.string_value(status);
  629. if (status != Token::StringValueStatus::Ok) {
  630. String message;
  631. if (status == Token::StringValueStatus::MalformedHexEscape || status == Token::StringValueStatus::MalformedUnicodeEscape) {
  632. auto type = status == Token::StringValueStatus::MalformedUnicodeEscape ? "unicode" : "hexadecimal";
  633. message = String::format("Malformed %s escape sequence", type);
  634. } else if (status == Token::StringValueStatus::UnicodeEscapeOverflow) {
  635. message = "Unicode codepoint must not be greater than 0x10ffff in escape sequence";
  636. }
  637. syntax_error(
  638. message,
  639. m_parser_state.m_current_token.line_number(),
  640. m_parser_state.m_current_token.line_column());
  641. }
  642. if (m_parser_state.m_use_strict_directive == UseStrictDirectiveState::Looking) {
  643. if (string == "use strict" && token.type() != TokenType::TemplateLiteralString) {
  644. m_parser_state.m_use_strict_directive = UseStrictDirectiveState::Found;
  645. } else {
  646. m_parser_state.m_use_strict_directive = UseStrictDirectiveState::None;
  647. }
  648. }
  649. return create_ast_node<StringLiteral>(string);
  650. }
  651. NonnullRefPtr<TemplateLiteral> Parser::parse_template_literal(bool is_tagged)
  652. {
  653. consume(TokenType::TemplateLiteralStart);
  654. NonnullRefPtrVector<Expression> expressions;
  655. NonnullRefPtrVector<Expression> raw_strings;
  656. auto append_empty_string = [&expressions, &raw_strings, is_tagged]() {
  657. auto string_literal = create_ast_node<StringLiteral>("");
  658. expressions.append(string_literal);
  659. if (is_tagged)
  660. raw_strings.append(string_literal);
  661. };
  662. if (!match(TokenType::TemplateLiteralString))
  663. append_empty_string();
  664. while (!done() && !match(TokenType::TemplateLiteralEnd) && !match(TokenType::UnterminatedTemplateLiteral)) {
  665. if (match(TokenType::TemplateLiteralString)) {
  666. auto token = consume();
  667. expressions.append(parse_string_literal(token));
  668. if (is_tagged)
  669. raw_strings.append(create_ast_node<StringLiteral>(token.value()));
  670. } else if (match(TokenType::TemplateLiteralExprStart)) {
  671. consume(TokenType::TemplateLiteralExprStart);
  672. if (match(TokenType::TemplateLiteralExprEnd)) {
  673. syntax_error("Empty template literal expression block");
  674. return create_ast_node<TemplateLiteral>(expressions);
  675. }
  676. expressions.append(parse_expression(0));
  677. if (match(TokenType::UnterminatedTemplateLiteral)) {
  678. syntax_error("Unterminated template literal");
  679. return create_ast_node<TemplateLiteral>(expressions);
  680. }
  681. consume(TokenType::TemplateLiteralExprEnd);
  682. if (!match(TokenType::TemplateLiteralString))
  683. append_empty_string();
  684. } else {
  685. expected("Template literal string or expression");
  686. break;
  687. }
  688. }
  689. if (match(TokenType::UnterminatedTemplateLiteral)) {
  690. syntax_error("Unterminated template literal");
  691. } else {
  692. consume(TokenType::TemplateLiteralEnd);
  693. }
  694. if (is_tagged)
  695. return create_ast_node<TemplateLiteral>(expressions, raw_strings);
  696. return create_ast_node<TemplateLiteral>(expressions);
  697. }
  698. NonnullRefPtr<Expression> Parser::parse_expression(int min_precedence, Associativity associativity, Vector<TokenType> forbidden)
  699. {
  700. auto expression = parse_primary_expression();
  701. while (match(TokenType::TemplateLiteralStart)) {
  702. auto template_literal = parse_template_literal(true);
  703. expression = create_ast_node<TaggedTemplateLiteral>(move(expression), move(template_literal));
  704. }
  705. while (match_secondary_expression(forbidden)) {
  706. int new_precedence = operator_precedence(m_parser_state.m_current_token.type());
  707. if (new_precedence < min_precedence)
  708. break;
  709. if (new_precedence == min_precedence && associativity == Associativity::Left)
  710. break;
  711. Associativity new_associativity = operator_associativity(m_parser_state.m_current_token.type());
  712. expression = parse_secondary_expression(move(expression), new_precedence, new_associativity);
  713. while (match(TokenType::TemplateLiteralStart)) {
  714. auto template_literal = parse_template_literal(true);
  715. expression = create_ast_node<TaggedTemplateLiteral>(move(expression), move(template_literal));
  716. }
  717. }
  718. if (match(TokenType::Comma) && min_precedence <= 1) {
  719. NonnullRefPtrVector<Expression> expressions;
  720. expressions.append(expression);
  721. while (match(TokenType::Comma)) {
  722. consume();
  723. expressions.append(parse_expression(2));
  724. }
  725. expression = create_ast_node<SequenceExpression>(move(expressions));
  726. }
  727. return expression;
  728. }
  729. NonnullRefPtr<Expression> Parser::parse_secondary_expression(NonnullRefPtr<Expression> lhs, int min_precedence, Associativity associativity)
  730. {
  731. switch (m_parser_state.m_current_token.type()) {
  732. case TokenType::Plus:
  733. consume();
  734. return create_ast_node<BinaryExpression>(BinaryOp::Addition, move(lhs), parse_expression(min_precedence, associativity));
  735. case TokenType::PlusEquals:
  736. consume();
  737. return create_ast_node<AssignmentExpression>(AssignmentOp::AdditionAssignment, move(lhs), parse_expression(min_precedence, associativity));
  738. case TokenType::Minus:
  739. consume();
  740. return create_ast_node<BinaryExpression>(BinaryOp::Subtraction, move(lhs), parse_expression(min_precedence, associativity));
  741. case TokenType::MinusEquals:
  742. consume();
  743. return create_ast_node<AssignmentExpression>(AssignmentOp::SubtractionAssignment, move(lhs), parse_expression(min_precedence, associativity));
  744. case TokenType::Asterisk:
  745. consume();
  746. return create_ast_node<BinaryExpression>(BinaryOp::Multiplication, move(lhs), parse_expression(min_precedence, associativity));
  747. case TokenType::AsteriskEquals:
  748. consume();
  749. return create_ast_node<AssignmentExpression>(AssignmentOp::MultiplicationAssignment, move(lhs), parse_expression(min_precedence, associativity));
  750. case TokenType::Slash:
  751. consume();
  752. return create_ast_node<BinaryExpression>(BinaryOp::Division, move(lhs), parse_expression(min_precedence, associativity));
  753. case TokenType::SlashEquals:
  754. consume();
  755. return create_ast_node<AssignmentExpression>(AssignmentOp::DivisionAssignment, move(lhs), parse_expression(min_precedence, associativity));
  756. case TokenType::Percent:
  757. consume();
  758. return create_ast_node<BinaryExpression>(BinaryOp::Modulo, move(lhs), parse_expression(min_precedence, associativity));
  759. case TokenType::PercentEquals:
  760. consume();
  761. return create_ast_node<AssignmentExpression>(AssignmentOp::ModuloAssignment, move(lhs), parse_expression(min_precedence, associativity));
  762. case TokenType::DoubleAsterisk:
  763. consume();
  764. return create_ast_node<BinaryExpression>(BinaryOp::Exponentiation, move(lhs), parse_expression(min_precedence, associativity));
  765. case TokenType::DoubleAsteriskEquals:
  766. consume();
  767. return create_ast_node<AssignmentExpression>(AssignmentOp::ExponentiationAssignment, move(lhs), parse_expression(min_precedence, associativity));
  768. case TokenType::GreaterThan:
  769. consume();
  770. return create_ast_node<BinaryExpression>(BinaryOp::GreaterThan, move(lhs), parse_expression(min_precedence, associativity));
  771. case TokenType::GreaterThanEquals:
  772. consume();
  773. return create_ast_node<BinaryExpression>(BinaryOp::GreaterThanEquals, move(lhs), parse_expression(min_precedence, associativity));
  774. case TokenType::LessThan:
  775. consume();
  776. return create_ast_node<BinaryExpression>(BinaryOp::LessThan, move(lhs), parse_expression(min_precedence, associativity));
  777. case TokenType::LessThanEquals:
  778. consume();
  779. return create_ast_node<BinaryExpression>(BinaryOp::LessThanEquals, move(lhs), parse_expression(min_precedence, associativity));
  780. case TokenType::EqualsEqualsEquals:
  781. consume();
  782. return create_ast_node<BinaryExpression>(BinaryOp::TypedEquals, move(lhs), parse_expression(min_precedence, associativity));
  783. case TokenType::ExclamationMarkEqualsEquals:
  784. consume();
  785. return create_ast_node<BinaryExpression>(BinaryOp::TypedInequals, move(lhs), parse_expression(min_precedence, associativity));
  786. case TokenType::EqualsEquals:
  787. consume();
  788. return create_ast_node<BinaryExpression>(BinaryOp::AbstractEquals, move(lhs), parse_expression(min_precedence, associativity));
  789. case TokenType::ExclamationMarkEquals:
  790. consume();
  791. return create_ast_node<BinaryExpression>(BinaryOp::AbstractInequals, move(lhs), parse_expression(min_precedence, associativity));
  792. case TokenType::In:
  793. consume();
  794. return create_ast_node<BinaryExpression>(BinaryOp::In, move(lhs), parse_expression(min_precedence, associativity));
  795. case TokenType::Instanceof:
  796. consume();
  797. return create_ast_node<BinaryExpression>(BinaryOp::InstanceOf, move(lhs), parse_expression(min_precedence, associativity));
  798. case TokenType::Ampersand:
  799. consume();
  800. return create_ast_node<BinaryExpression>(BinaryOp::BitwiseAnd, move(lhs), parse_expression(min_precedence, associativity));
  801. case TokenType::AmpersandEquals:
  802. consume();
  803. return create_ast_node<AssignmentExpression>(AssignmentOp::BitwiseAndAssignment, move(lhs), parse_expression(min_precedence, associativity));
  804. case TokenType::Pipe:
  805. consume();
  806. return create_ast_node<BinaryExpression>(BinaryOp::BitwiseOr, move(lhs), parse_expression(min_precedence, associativity));
  807. case TokenType::PipeEquals:
  808. consume();
  809. return create_ast_node<AssignmentExpression>(AssignmentOp::BitwiseOrAssignment, move(lhs), parse_expression(min_precedence, associativity));
  810. case TokenType::Caret:
  811. consume();
  812. return create_ast_node<BinaryExpression>(BinaryOp::BitwiseXor, move(lhs), parse_expression(min_precedence, associativity));
  813. case TokenType::CaretEquals:
  814. consume();
  815. return create_ast_node<AssignmentExpression>(AssignmentOp::BitwiseXorAssignment, move(lhs), parse_expression(min_precedence, associativity));
  816. case TokenType::ShiftLeft:
  817. consume();
  818. return create_ast_node<BinaryExpression>(BinaryOp::LeftShift, move(lhs), parse_expression(min_precedence, associativity));
  819. case TokenType::ShiftLeftEquals:
  820. consume();
  821. return create_ast_node<AssignmentExpression>(AssignmentOp::LeftShiftAssignment, move(lhs), parse_expression(min_precedence, associativity));
  822. case TokenType::ShiftRight:
  823. consume();
  824. return create_ast_node<BinaryExpression>(BinaryOp::RightShift, move(lhs), parse_expression(min_precedence, associativity));
  825. case TokenType::ShiftRightEquals:
  826. consume();
  827. return create_ast_node<AssignmentExpression>(AssignmentOp::RightShiftAssignment, move(lhs), parse_expression(min_precedence, associativity));
  828. case TokenType::UnsignedShiftRight:
  829. consume();
  830. return create_ast_node<BinaryExpression>(BinaryOp::UnsignedRightShift, move(lhs), parse_expression(min_precedence, associativity));
  831. case TokenType::UnsignedShiftRightEquals:
  832. consume();
  833. return create_ast_node<AssignmentExpression>(AssignmentOp::UnsignedRightShiftAssignment, move(lhs), parse_expression(min_precedence, associativity));
  834. case TokenType::ParenOpen:
  835. return parse_call_expression(move(lhs));
  836. case TokenType::Equals:
  837. consume();
  838. if (!lhs->is_identifier() && !lhs->is_member_expression() && !lhs->is_call_expression()) {
  839. syntax_error("Invalid left-hand side in assignment");
  840. return create_ast_node<ErrorExpression>();
  841. }
  842. if (m_parser_state.m_strict_mode && lhs->is_identifier()) {
  843. auto name = static_cast<const Identifier&>(*lhs).string();
  844. if (name == "eval" || name == "arguments") {
  845. syntax_error(
  846. String::format("'%s' cannot be assigned to in strict mode code", name.characters()),
  847. m_parser_state.m_current_token.line_number(),
  848. m_parser_state.m_current_token.line_column());
  849. }
  850. }
  851. return create_ast_node<AssignmentExpression>(AssignmentOp::Assignment, move(lhs), parse_expression(min_precedence, associativity));
  852. case TokenType::Period:
  853. consume();
  854. if (!match_identifier_name())
  855. expected("IdentifierName");
  856. return create_ast_node<MemberExpression>(move(lhs), create_ast_node<Identifier>(consume().value()));
  857. case TokenType::BracketOpen: {
  858. consume(TokenType::BracketOpen);
  859. auto expression = create_ast_node<MemberExpression>(move(lhs), parse_expression(0), true);
  860. consume(TokenType::BracketClose);
  861. return expression;
  862. }
  863. case TokenType::PlusPlus:
  864. if (!lhs->is_identifier() && !lhs->is_member_expression())
  865. syntax_error(String::format("Left-hand side of postfix increment operator must be identifier or member expression, got %s", lhs->class_name()));
  866. consume();
  867. return create_ast_node<UpdateExpression>(UpdateOp::Increment, move(lhs));
  868. case TokenType::MinusMinus:
  869. if (!lhs->is_identifier() && !lhs->is_member_expression())
  870. syntax_error(String::format("Left-hand side of postfix increment operator must be identifier or member expression, got %s", lhs->class_name()));
  871. consume();
  872. return create_ast_node<UpdateExpression>(UpdateOp::Decrement, move(lhs));
  873. case TokenType::DoubleAmpersand:
  874. consume();
  875. return create_ast_node<LogicalExpression>(LogicalOp::And, move(lhs), parse_expression(min_precedence, associativity));
  876. case TokenType::DoublePipe:
  877. consume();
  878. return create_ast_node<LogicalExpression>(LogicalOp::Or, move(lhs), parse_expression(min_precedence, associativity));
  879. case TokenType::DoubleQuestionMark:
  880. consume();
  881. return create_ast_node<LogicalExpression>(LogicalOp::NullishCoalescing, move(lhs), parse_expression(min_precedence, associativity));
  882. case TokenType::QuestionMark:
  883. return parse_conditional_expression(move(lhs));
  884. default:
  885. expected("secondary expression (missing switch case)");
  886. consume();
  887. return create_ast_node<ErrorExpression>();
  888. }
  889. }
  890. NonnullRefPtr<CallExpression> Parser::parse_call_expression(NonnullRefPtr<Expression> lhs)
  891. {
  892. consume(TokenType::ParenOpen);
  893. Vector<CallExpression::Argument> arguments;
  894. while (match_expression() || match(TokenType::TripleDot)) {
  895. if (match(TokenType::TripleDot)) {
  896. consume();
  897. arguments.append({ parse_expression(2), true });
  898. } else {
  899. arguments.append({ parse_expression(2), false });
  900. }
  901. if (!match(TokenType::Comma))
  902. break;
  903. consume();
  904. }
  905. consume(TokenType::ParenClose);
  906. return create_ast_node<CallExpression>(move(lhs), move(arguments));
  907. }
  908. NonnullRefPtr<NewExpression> Parser::parse_new_expression()
  909. {
  910. consume(TokenType::New);
  911. auto callee = parse_expression(g_operator_precedence.get(TokenType::New).value(), Associativity::Right, { TokenType::ParenOpen });
  912. Vector<CallExpression::Argument> arguments;
  913. if (match(TokenType::ParenOpen)) {
  914. consume(TokenType::ParenOpen);
  915. while (match_expression() || match(TokenType::TripleDot)) {
  916. if (match(TokenType::TripleDot)) {
  917. consume();
  918. arguments.append({ parse_expression(2), true });
  919. } else {
  920. arguments.append({ parse_expression(2), false });
  921. }
  922. if (!match(TokenType::Comma))
  923. break;
  924. consume();
  925. }
  926. consume(TokenType::ParenClose);
  927. }
  928. return create_ast_node<NewExpression>(move(callee), move(arguments));
  929. }
  930. NonnullRefPtr<ReturnStatement> Parser::parse_return_statement()
  931. {
  932. consume(TokenType::Return);
  933. // Automatic semicolon insertion: terminate statement when return is followed by newline
  934. if (m_parser_state.m_current_token.trivia().contains('\n'))
  935. return create_ast_node<ReturnStatement>(nullptr);
  936. if (match_expression()) {
  937. auto expression = parse_expression(0);
  938. consume_or_insert_semicolon();
  939. return create_ast_node<ReturnStatement>(move(expression));
  940. }
  941. consume_or_insert_semicolon();
  942. return create_ast_node<ReturnStatement>(nullptr);
  943. }
  944. NonnullRefPtr<BlockStatement> Parser::parse_block_statement()
  945. {
  946. ScopePusher scope(*this, ScopePusher::Let);
  947. auto block = create_ast_node<BlockStatement>();
  948. consume(TokenType::CurlyOpen);
  949. bool first = true;
  950. bool initial_strict_mode_state = m_parser_state.m_strict_mode;
  951. if (initial_strict_mode_state) {
  952. m_parser_state.m_use_strict_directive = UseStrictDirectiveState::None;
  953. block->set_strict_mode();
  954. } else {
  955. m_parser_state.m_use_strict_directive = UseStrictDirectiveState::Looking;
  956. }
  957. while (!done() && !match(TokenType::CurlyClose)) {
  958. if (match(TokenType::Semicolon)) {
  959. consume();
  960. } else if (match_statement()) {
  961. block->append(parse_statement());
  962. if (first && !initial_strict_mode_state) {
  963. if (m_parser_state.m_use_strict_directive == UseStrictDirectiveState::Found) {
  964. block->set_strict_mode();
  965. m_parser_state.m_strict_mode = true;
  966. }
  967. m_parser_state.m_use_strict_directive = UseStrictDirectiveState::None;
  968. }
  969. } else {
  970. expected("statement");
  971. consume();
  972. }
  973. first = false;
  974. }
  975. m_parser_state.m_strict_mode = initial_strict_mode_state;
  976. consume(TokenType::CurlyClose);
  977. block->add_variables(m_parser_state.m_let_scopes.last());
  978. block->add_functions(m_parser_state.m_function_scopes.last());
  979. return block;
  980. }
  981. template<typename FunctionNodeType>
  982. NonnullRefPtr<FunctionNodeType> Parser::parse_function_node(bool check_for_function_and_name)
  983. {
  984. ScopePusher scope(*this, ScopePusher::Var | ScopePusher::Function);
  985. if (check_for_function_and_name)
  986. consume(TokenType::Function);
  987. String name;
  988. if (check_for_function_and_name) {
  989. if (FunctionNodeType::must_have_name()) {
  990. name = consume(TokenType::Identifier).value();
  991. } else {
  992. if (match(TokenType::Identifier))
  993. name = consume(TokenType::Identifier).value();
  994. }
  995. }
  996. consume(TokenType::ParenOpen);
  997. Vector<FunctionNode::Parameter> parameters;
  998. i32 function_length = -1;
  999. while (match(TokenType::Identifier) || match(TokenType::TripleDot)) {
  1000. if (match(TokenType::TripleDot)) {
  1001. consume();
  1002. auto parameter_name = consume(TokenType::Identifier).value();
  1003. function_length = parameters.size();
  1004. parameters.append({ parameter_name, nullptr, true });
  1005. break;
  1006. }
  1007. auto parameter_name = consume(TokenType::Identifier).value();
  1008. RefPtr<Expression> default_value;
  1009. if (match(TokenType::Equals)) {
  1010. consume(TokenType::Equals);
  1011. function_length = parameters.size();
  1012. default_value = parse_expression(2);
  1013. }
  1014. parameters.append({ parameter_name, default_value });
  1015. if (match(TokenType::ParenClose))
  1016. break;
  1017. consume(TokenType::Comma);
  1018. }
  1019. consume(TokenType::ParenClose);
  1020. if (function_length == -1)
  1021. function_length = parameters.size();
  1022. auto body = parse_block_statement();
  1023. body->add_variables(m_parser_state.m_var_scopes.last());
  1024. body->add_functions(m_parser_state.m_function_scopes.last());
  1025. return create_ast_node<FunctionNodeType>(name, move(body), move(parameters), function_length, NonnullRefPtrVector<VariableDeclaration>());
  1026. }
  1027. NonnullRefPtr<VariableDeclaration> Parser::parse_variable_declaration(bool with_semicolon)
  1028. {
  1029. DeclarationKind declaration_kind;
  1030. switch (m_parser_state.m_current_token.type()) {
  1031. case TokenType::Var:
  1032. declaration_kind = DeclarationKind::Var;
  1033. consume(TokenType::Var);
  1034. break;
  1035. case TokenType::Let:
  1036. declaration_kind = DeclarationKind::Let;
  1037. consume(TokenType::Let);
  1038. break;
  1039. case TokenType::Const:
  1040. declaration_kind = DeclarationKind::Const;
  1041. consume(TokenType::Const);
  1042. break;
  1043. default:
  1044. ASSERT_NOT_REACHED();
  1045. }
  1046. NonnullRefPtrVector<VariableDeclarator> declarations;
  1047. for (;;) {
  1048. auto id = consume(TokenType::Identifier).value();
  1049. RefPtr<Expression> init;
  1050. if (match(TokenType::Equals)) {
  1051. consume();
  1052. init = parse_expression(2);
  1053. }
  1054. declarations.append(create_ast_node<VariableDeclarator>(create_ast_node<Identifier>(move(id)), move(init)));
  1055. if (match(TokenType::Comma)) {
  1056. consume();
  1057. continue;
  1058. }
  1059. break;
  1060. }
  1061. if (with_semicolon)
  1062. consume_or_insert_semicolon();
  1063. auto declaration = create_ast_node<VariableDeclaration>(declaration_kind, move(declarations));
  1064. if (declaration_kind == DeclarationKind::Var)
  1065. m_parser_state.m_var_scopes.last().append(declaration);
  1066. else
  1067. m_parser_state.m_let_scopes.last().append(declaration);
  1068. return declaration;
  1069. }
  1070. NonnullRefPtr<ThrowStatement> Parser::parse_throw_statement()
  1071. {
  1072. consume(TokenType::Throw);
  1073. // Automatic semicolon insertion: terminate statement when throw is followed by newline
  1074. if (m_parser_state.m_current_token.trivia().contains('\n')) {
  1075. syntax_error("No line break is allowed between 'throw' and its expression");
  1076. return create_ast_node<ThrowStatement>(create_ast_node<ErrorExpression>());
  1077. }
  1078. auto expression = parse_expression(0);
  1079. consume_or_insert_semicolon();
  1080. return create_ast_node<ThrowStatement>(move(expression));
  1081. }
  1082. NonnullRefPtr<BreakStatement> Parser::parse_break_statement()
  1083. {
  1084. consume(TokenType::Break);
  1085. FlyString target_label;
  1086. if (match(TokenType::Semicolon)) {
  1087. consume();
  1088. return create_ast_node<BreakStatement>(target_label);
  1089. }
  1090. if (match(TokenType::Identifier) && !m_parser_state.m_current_token.trivia().contains('\n'))
  1091. target_label = consume().value();
  1092. consume_or_insert_semicolon();
  1093. return create_ast_node<BreakStatement>(target_label);
  1094. }
  1095. NonnullRefPtr<ContinueStatement> Parser::parse_continue_statement()
  1096. {
  1097. consume(TokenType::Continue);
  1098. FlyString target_label;
  1099. if (match(TokenType::Semicolon)) {
  1100. consume();
  1101. return create_ast_node<ContinueStatement>(target_label);
  1102. }
  1103. if (match(TokenType::Identifier) && !m_parser_state.m_current_token.trivia().contains('\n'))
  1104. target_label = consume().value();
  1105. consume_or_insert_semicolon();
  1106. return create_ast_node<ContinueStatement>(target_label);
  1107. }
  1108. NonnullRefPtr<ConditionalExpression> Parser::parse_conditional_expression(NonnullRefPtr<Expression> test)
  1109. {
  1110. consume(TokenType::QuestionMark);
  1111. auto consequent = parse_expression(2);
  1112. consume(TokenType::Colon);
  1113. auto alternate = parse_expression(2);
  1114. return create_ast_node<ConditionalExpression>(move(test), move(consequent), move(alternate));
  1115. }
  1116. NonnullRefPtr<TryStatement> Parser::parse_try_statement()
  1117. {
  1118. consume(TokenType::Try);
  1119. auto block = parse_block_statement();
  1120. RefPtr<CatchClause> handler;
  1121. if (match(TokenType::Catch))
  1122. handler = parse_catch_clause();
  1123. RefPtr<BlockStatement> finalizer;
  1124. if (match(TokenType::Finally)) {
  1125. consume();
  1126. finalizer = parse_block_statement();
  1127. }
  1128. return create_ast_node<TryStatement>(move(block), move(handler), move(finalizer));
  1129. }
  1130. NonnullRefPtr<DoWhileStatement> Parser::parse_do_while_statement()
  1131. {
  1132. consume(TokenType::Do);
  1133. auto body = parse_statement();
  1134. consume(TokenType::While);
  1135. consume(TokenType::ParenOpen);
  1136. auto test = parse_expression(0);
  1137. consume(TokenType::ParenClose);
  1138. consume_or_insert_semicolon();
  1139. return create_ast_node<DoWhileStatement>(move(test), move(body));
  1140. }
  1141. NonnullRefPtr<WhileStatement> Parser::parse_while_statement()
  1142. {
  1143. consume(TokenType::While);
  1144. consume(TokenType::ParenOpen);
  1145. auto test = parse_expression(0);
  1146. consume(TokenType::ParenClose);
  1147. auto body = parse_statement();
  1148. return create_ast_node<WhileStatement>(move(test), move(body));
  1149. }
  1150. NonnullRefPtr<SwitchStatement> Parser::parse_switch_statement()
  1151. {
  1152. consume(TokenType::Switch);
  1153. consume(TokenType::ParenOpen);
  1154. auto determinant = parse_expression(0);
  1155. consume(TokenType::ParenClose);
  1156. consume(TokenType::CurlyOpen);
  1157. NonnullRefPtrVector<SwitchCase> cases;
  1158. while (match(TokenType::Case) || match(TokenType::Default))
  1159. cases.append(parse_switch_case());
  1160. consume(TokenType::CurlyClose);
  1161. return create_ast_node<SwitchStatement>(move(determinant), move(cases));
  1162. }
  1163. NonnullRefPtr<SwitchCase> Parser::parse_switch_case()
  1164. {
  1165. RefPtr<Expression> test;
  1166. if (consume().type() == TokenType::Case) {
  1167. test = parse_expression(0);
  1168. }
  1169. consume(TokenType::Colon);
  1170. NonnullRefPtrVector<Statement> consequent;
  1171. while (match_statement())
  1172. consequent.append(parse_statement());
  1173. return create_ast_node<SwitchCase>(move(test), move(consequent));
  1174. }
  1175. NonnullRefPtr<CatchClause> Parser::parse_catch_clause()
  1176. {
  1177. consume(TokenType::Catch);
  1178. String parameter;
  1179. if (match(TokenType::ParenOpen)) {
  1180. consume();
  1181. parameter = consume(TokenType::Identifier).value();
  1182. consume(TokenType::ParenClose);
  1183. }
  1184. auto body = parse_block_statement();
  1185. return create_ast_node<CatchClause>(parameter, move(body));
  1186. }
  1187. NonnullRefPtr<IfStatement> Parser::parse_if_statement()
  1188. {
  1189. consume(TokenType::If);
  1190. consume(TokenType::ParenOpen);
  1191. auto predicate = parse_expression(0);
  1192. consume(TokenType::ParenClose);
  1193. auto consequent = parse_statement();
  1194. RefPtr<Statement> alternate;
  1195. if (match(TokenType::Else)) {
  1196. consume(TokenType::Else);
  1197. alternate = parse_statement();
  1198. }
  1199. return create_ast_node<IfStatement>(move(predicate), move(consequent), move(alternate));
  1200. }
  1201. NonnullRefPtr<Statement> Parser::parse_for_statement()
  1202. {
  1203. auto match_for_in_of = [&]() {
  1204. return match(TokenType::In) || (match(TokenType::Identifier) && m_parser_state.m_current_token.value() == "of");
  1205. };
  1206. consume(TokenType::For);
  1207. consume(TokenType::ParenOpen);
  1208. bool in_scope = false;
  1209. RefPtr<ASTNode> init;
  1210. if (!match(TokenType::Semicolon)) {
  1211. if (match_expression()) {
  1212. init = parse_expression(0, Associativity::Right, { TokenType::In });
  1213. if (match_for_in_of())
  1214. return parse_for_in_of_statement(*init);
  1215. } else if (match_variable_declaration()) {
  1216. if (!match(TokenType::Var)) {
  1217. m_parser_state.m_let_scopes.append(NonnullRefPtrVector<VariableDeclaration>());
  1218. in_scope = true;
  1219. }
  1220. init = parse_variable_declaration(false);
  1221. if (match_for_in_of())
  1222. return parse_for_in_of_statement(*init);
  1223. } else {
  1224. syntax_error("Unexpected token in for loop");
  1225. }
  1226. }
  1227. consume(TokenType::Semicolon);
  1228. RefPtr<Expression> test;
  1229. if (!match(TokenType::Semicolon))
  1230. test = parse_expression(0);
  1231. consume(TokenType::Semicolon);
  1232. RefPtr<Expression> update;
  1233. if (!match(TokenType::ParenClose))
  1234. update = parse_expression(0);
  1235. consume(TokenType::ParenClose);
  1236. auto body = parse_statement();
  1237. if (in_scope) {
  1238. m_parser_state.m_let_scopes.take_last();
  1239. }
  1240. return create_ast_node<ForStatement>(move(init), move(test), move(update), move(body));
  1241. }
  1242. NonnullRefPtr<Statement> Parser::parse_for_in_of_statement(NonnullRefPtr<ASTNode> lhs)
  1243. {
  1244. if (lhs->is_variable_declaration()) {
  1245. auto declarations = static_cast<VariableDeclaration*>(lhs.ptr())->declarations();
  1246. if (declarations.size() > 1) {
  1247. syntax_error("multiple declarations not allowed in for..in/of");
  1248. lhs = create_ast_node<ErrorExpression>();
  1249. }
  1250. if (declarations.first().init() != nullptr) {
  1251. syntax_error("variable initializer not allowed in for..in/of");
  1252. lhs = create_ast_node<ErrorExpression>();
  1253. }
  1254. }
  1255. auto in_or_of = consume();
  1256. auto rhs = parse_expression(0);
  1257. consume(TokenType::ParenClose);
  1258. auto body = parse_statement();
  1259. if (in_or_of.type() == TokenType::In)
  1260. return create_ast_node<ForInStatement>(move(lhs), move(rhs), move(body));
  1261. return create_ast_node<ForOfStatement>(move(lhs), move(rhs), move(body));
  1262. }
  1263. NonnullRefPtr<DebuggerStatement> Parser::parse_debugger_statement()
  1264. {
  1265. consume(TokenType::Debugger);
  1266. consume_or_insert_semicolon();
  1267. return create_ast_node<DebuggerStatement>();
  1268. }
  1269. bool Parser::match(TokenType type) const
  1270. {
  1271. return m_parser_state.m_current_token.type() == type;
  1272. }
  1273. bool Parser::match_variable_declaration() const
  1274. {
  1275. switch (m_parser_state.m_current_token.type()) {
  1276. case TokenType::Var:
  1277. case TokenType::Let:
  1278. case TokenType::Const:
  1279. return true;
  1280. default:
  1281. return false;
  1282. }
  1283. }
  1284. bool Parser::match_expression() const
  1285. {
  1286. auto type = m_parser_state.m_current_token.type();
  1287. return type == TokenType::BoolLiteral
  1288. || type == TokenType::NumericLiteral
  1289. || type == TokenType::BigIntLiteral
  1290. || type == TokenType::StringLiteral
  1291. || type == TokenType::TemplateLiteralStart
  1292. || type == TokenType::NullLiteral
  1293. || type == TokenType::Identifier
  1294. || type == TokenType::New
  1295. || type == TokenType::CurlyOpen
  1296. || type == TokenType::BracketOpen
  1297. || type == TokenType::ParenOpen
  1298. || type == TokenType::Function
  1299. || type == TokenType::This
  1300. || type == TokenType::RegexLiteral
  1301. || match_unary_prefixed_expression();
  1302. }
  1303. bool Parser::match_unary_prefixed_expression() const
  1304. {
  1305. auto type = m_parser_state.m_current_token.type();
  1306. return type == TokenType::PlusPlus
  1307. || type == TokenType::MinusMinus
  1308. || type == TokenType::ExclamationMark
  1309. || type == TokenType::Tilde
  1310. || type == TokenType::Plus
  1311. || type == TokenType::Minus
  1312. || type == TokenType::Typeof
  1313. || type == TokenType::Void
  1314. || type == TokenType::Delete;
  1315. }
  1316. bool Parser::match_secondary_expression(Vector<TokenType> forbidden) const
  1317. {
  1318. auto type = m_parser_state.m_current_token.type();
  1319. if (forbidden.contains_slow(type))
  1320. return false;
  1321. return type == TokenType::Plus
  1322. || type == TokenType::PlusEquals
  1323. || type == TokenType::Minus
  1324. || type == TokenType::MinusEquals
  1325. || type == TokenType::Asterisk
  1326. || type == TokenType::AsteriskEquals
  1327. || type == TokenType::Slash
  1328. || type == TokenType::SlashEquals
  1329. || type == TokenType::Percent
  1330. || type == TokenType::PercentEquals
  1331. || type == TokenType::DoubleAsterisk
  1332. || type == TokenType::DoubleAsteriskEquals
  1333. || type == TokenType::Equals
  1334. || type == TokenType::EqualsEqualsEquals
  1335. || type == TokenType::ExclamationMarkEqualsEquals
  1336. || type == TokenType::EqualsEquals
  1337. || type == TokenType::ExclamationMarkEquals
  1338. || type == TokenType::GreaterThan
  1339. || type == TokenType::GreaterThanEquals
  1340. || type == TokenType::LessThan
  1341. || type == TokenType::LessThanEquals
  1342. || type == TokenType::ParenOpen
  1343. || type == TokenType::Period
  1344. || type == TokenType::BracketOpen
  1345. || type == TokenType::PlusPlus
  1346. || type == TokenType::MinusMinus
  1347. || type == TokenType::In
  1348. || type == TokenType::Instanceof
  1349. || type == TokenType::QuestionMark
  1350. || type == TokenType::Ampersand
  1351. || type == TokenType::AmpersandEquals
  1352. || type == TokenType::Pipe
  1353. || type == TokenType::PipeEquals
  1354. || type == TokenType::Caret
  1355. || type == TokenType::CaretEquals
  1356. || type == TokenType::ShiftLeft
  1357. || type == TokenType::ShiftLeftEquals
  1358. || type == TokenType::ShiftRight
  1359. || type == TokenType::ShiftRightEquals
  1360. || type == TokenType::UnsignedShiftRight
  1361. || type == TokenType::UnsignedShiftRightEquals
  1362. || type == TokenType::DoubleAmpersand
  1363. || type == TokenType::DoublePipe
  1364. || type == TokenType::DoubleQuestionMark;
  1365. }
  1366. bool Parser::match_statement() const
  1367. {
  1368. auto type = m_parser_state.m_current_token.type();
  1369. return match_expression()
  1370. || type == TokenType::Function
  1371. || type == TokenType::Return
  1372. || type == TokenType::Let
  1373. || type == TokenType::Class
  1374. || type == TokenType::Do
  1375. || type == TokenType::If
  1376. || type == TokenType::Throw
  1377. || type == TokenType::Try
  1378. || type == TokenType::While
  1379. || type == TokenType::For
  1380. || type == TokenType::Const
  1381. || type == TokenType::CurlyOpen
  1382. || type == TokenType::Switch
  1383. || type == TokenType::Break
  1384. || type == TokenType::Continue
  1385. || type == TokenType::Var
  1386. || type == TokenType::Debugger
  1387. || type == TokenType::Semicolon;
  1388. }
  1389. bool Parser::match_identifier_name() const
  1390. {
  1391. return m_parser_state.m_current_token.is_identifier_name();
  1392. }
  1393. bool Parser::done() const
  1394. {
  1395. return match(TokenType::Eof);
  1396. }
  1397. Token Parser::consume()
  1398. {
  1399. auto old_token = m_parser_state.m_current_token;
  1400. m_parser_state.m_current_token = m_parser_state.m_lexer.next();
  1401. return old_token;
  1402. }
  1403. void Parser::consume_or_insert_semicolon()
  1404. {
  1405. // Semicolon was found and will be consumed
  1406. if (match(TokenType::Semicolon)) {
  1407. consume();
  1408. return;
  1409. }
  1410. // Insert semicolon if...
  1411. // ...token is preceeded by one or more newlines
  1412. if (m_parser_state.m_current_token.trivia().contains('\n'))
  1413. return;
  1414. // ...token is a closing curly brace
  1415. if (match(TokenType::CurlyClose))
  1416. return;
  1417. // ...token is eof
  1418. if (match(TokenType::Eof))
  1419. return;
  1420. // No rule for semicolon insertion applies -> syntax error
  1421. expected("Semicolon");
  1422. }
  1423. Token Parser::consume(TokenType expected_type)
  1424. {
  1425. if (!match(expected_type)) {
  1426. expected(Token::name(expected_type));
  1427. }
  1428. return consume();
  1429. }
  1430. void Parser::expected(const char* what)
  1431. {
  1432. syntax_error(String::format("Unexpected token %s. Expected %s", m_parser_state.m_current_token.name(), what));
  1433. }
  1434. void Parser::syntax_error(const String& message, size_t line, size_t column)
  1435. {
  1436. if (line == 0 || column == 0) {
  1437. line = m_parser_state.m_current_token.line_number();
  1438. column = m_parser_state.m_current_token.line_column();
  1439. }
  1440. m_parser_state.m_errors.append({ message, line, column });
  1441. }
  1442. void Parser::save_state()
  1443. {
  1444. m_saved_state.append(m_parser_state);
  1445. }
  1446. void Parser::load_state()
  1447. {
  1448. ASSERT(!m_saved_state.is_empty());
  1449. m_parser_state = m_saved_state.take_last();
  1450. }
  1451. }