TextParser.cpp 26 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822
  1. /*
  2. * Copyright (c) 2023, Dan Klishch <danilklishch@gmail.com>
  3. *
  4. * SPDX-License-Identifier: BSD-2-Clause
  5. */
  6. #include <AK/ScopeGuard.h>
  7. #include "Parser/SpecificationParsing.h"
  8. #include "Parser/TextParser.h"
  9. namespace JSSpecCompiler {
  10. void TextParser::save_error(Variant<TokenType, StringView, CustomMessage>&& expected)
  11. {
  12. if (expected.has<TokenType>() && expected.get<TokenType>() == TokenType::Invalid)
  13. return;
  14. if (m_max_parsed_tokens > m_next_token_index)
  15. return;
  16. if (m_max_parsed_tokens < m_next_token_index)
  17. m_suitable_continuations.clear();
  18. m_max_parsed_tokens = m_next_token_index;
  19. m_suitable_continuations.append(move(expected));
  20. }
  21. void TextParser::retreat()
  22. {
  23. --m_next_token_index;
  24. }
  25. auto TextParser::rollback_point()
  26. {
  27. return ArmedScopeGuard {
  28. [this, index = this->m_next_token_index] {
  29. m_next_token_index = index;
  30. }
  31. };
  32. }
  33. Optional<Token> TextParser::peek_token()
  34. {
  35. if (m_next_token_index == m_tokens.size())
  36. return {};
  37. return m_tokens[m_next_token_index];
  38. }
  39. Optional<Token> TextParser::consume_token()
  40. {
  41. auto result = peek_token();
  42. if (result.has_value())
  43. ++m_next_token_index;
  44. return result;
  45. }
  46. TextParseErrorOr<Token> TextParser::consume_token_with_one_of_types(std::initializer_list<TokenType> types)
  47. {
  48. auto token = peek_token();
  49. if (token.has_value()) {
  50. for (TokenType type : types) {
  51. if (token->type == type) {
  52. (void)consume_token();
  53. return *token;
  54. } else {
  55. save_error(type);
  56. }
  57. }
  58. } else {
  59. for (TokenType type : types)
  60. save_error(type);
  61. }
  62. return TextParseError {};
  63. }
  64. TextParseErrorOr<Token> TextParser::consume_token_with_type(TokenType type)
  65. {
  66. return consume_token_with_one_of_types({ type });
  67. }
  68. TextParseErrorOr<void> TextParser::consume_token(TokenType type, StringView data)
  69. {
  70. auto token = consume_token();
  71. if (!token.has_value() || token->type != type || !token->data.equals_ignoring_ascii_case(data)) {
  72. retreat();
  73. save_error(data);
  74. return TextParseError {};
  75. }
  76. return {};
  77. }
  78. TextParseErrorOr<void> TextParser::consume_word(StringView word)
  79. {
  80. auto token = consume_token();
  81. if (!token.has_value() || token->type != TokenType::Word || !token->data.equals_ignoring_ascii_case(word)) {
  82. retreat();
  83. save_error(word);
  84. return TextParseError {};
  85. }
  86. return {};
  87. }
  88. TextParseErrorOr<void> TextParser::consume_words(std::initializer_list<StringView> words)
  89. {
  90. for (auto word : words)
  91. TRY(consume_word(word));
  92. return {};
  93. }
  94. bool TextParser::is_eof() const
  95. {
  96. return m_next_token_index == m_tokens.size();
  97. }
  98. TextParseErrorOr<void> TextParser::expect_eof()
  99. {
  100. if (!is_eof()) {
  101. save_error(CustomMessage { "EOF"sv });
  102. return TextParseError {};
  103. }
  104. return {};
  105. }
  106. // <record_initialization> :== (the)? <record_name> { (<name>: <value>,)* }
  107. TextParseErrorOr<Tree> TextParser::parse_record_direct_list_initialization()
  108. {
  109. auto rollback = rollback_point();
  110. (void)consume_word("the"sv);
  111. auto identifier = TRY(consume_token_with_type(TokenType::Identifier));
  112. TRY(consume_token_with_type(TokenType::BraceOpen));
  113. Vector<RecordDirectListInitialization::Argument> arguments;
  114. while (true) {
  115. auto name = TRY(consume_token_with_one_of_types({ TokenType::Identifier, TokenType::BraceClose }));
  116. if (name.is_bracket()) {
  117. break;
  118. } else {
  119. TRY(consume_token_with_type(TokenType::Colon));
  120. auto value = TRY(parse_expression());
  121. (void)consume_token_with_type(TokenType::Comma);
  122. arguments.append({ make_ref_counted<UnresolvedReference>(name.data), value });
  123. }
  124. }
  125. rollback.disarm();
  126. return make_ref_counted<RecordDirectListInitialization>(
  127. make_ref_counted<UnresolvedReference>(identifier.data), move(arguments));
  128. }
  129. // <function_arguments> :== '(' (<expr> (, <expr>)* )? ')'
  130. TextParseErrorOr<Vector<Tree>> TextParser::parse_function_arguments()
  131. {
  132. auto rollback = rollback_point();
  133. TRY(consume_token_with_type(TokenType::ParenOpen));
  134. if (!consume_token_with_type(TokenType::ParenClose).is_error()) {
  135. rollback.disarm();
  136. return Vector<Tree> {};
  137. }
  138. Vector<Tree> arguments;
  139. while (true) {
  140. arguments.append(TRY(parse_expression()));
  141. auto token = TRY(consume_token_with_one_of_types({ TokenType::ParenClose, TokenType::Comma }));
  142. if (token.type == TokenType::ParenClose)
  143. break;
  144. }
  145. rollback.disarm();
  146. return arguments;
  147. }
  148. // <list_initialization> :== « (<expr> (, <expr>)*)? »
  149. TextParseErrorOr<Tree> TextParser::parse_list_initialization()
  150. {
  151. auto rollback = rollback_point();
  152. TRY(consume_token_with_type(TokenType::ListStart));
  153. if (!consume_token_with_type(TokenType::ListEnd).is_error()) {
  154. rollback.disarm();
  155. return make_ref_counted<List>(Vector<Tree> {});
  156. }
  157. Vector<Tree> elements;
  158. while (true) {
  159. elements.append(TRY(parse_expression()));
  160. auto token = TRY(consume_token_with_one_of_types({ TokenType::ListEnd, TokenType::Comma }));
  161. if (token.type == TokenType::ListEnd)
  162. break;
  163. }
  164. rollback.disarm();
  165. return make_ref_counted<List>(move(elements));
  166. }
  167. TextParseErrorOr<Tree> TextParser::parse_the_this_value()
  168. {
  169. auto rollback = rollback_point();
  170. TRY(consume_word("the"sv));
  171. TRY(consume_token(TokenType::WellKnownValue, "this"sv));
  172. TRY(consume_word("value"sv));
  173. rollback.disarm();
  174. return make_ref_counted<WellKnownNode>(WellKnownNode::Type::This);
  175. }
  176. // <value> :== <identifier> | <well_known_value> | <enumerator> | <number> | <string> | <list_initialization> | <record_initialization>
  177. TextParseErrorOr<Tree> TextParser::parse_value()
  178. {
  179. if (auto identifier = consume_token_with_type(TokenType::Identifier); !identifier.is_error())
  180. return make_ref_counted<UnresolvedReference>(identifier.release_value().data);
  181. if (auto well_known_value = consume_token_with_type(TokenType::WellKnownValue); !well_known_value.is_error()) {
  182. static constexpr struct {
  183. StringView name;
  184. WellKnownNode::Type type;
  185. } translations[] = {
  186. { "false"sv, WellKnownNode::Type::False },
  187. { "NewTarget"sv, WellKnownNode::Type::NewTarget },
  188. { "null"sv, WellKnownNode::Type::Null },
  189. { "this"sv, WellKnownNode::Type::This },
  190. { "true"sv, WellKnownNode::Type::True },
  191. { "undefined"sv, WellKnownNode::Type::Undefined },
  192. };
  193. for (auto [name, type] : translations)
  194. if (well_known_value.value().data == name)
  195. return make_ref_counted<WellKnownNode>(type);
  196. VERIFY_NOT_REACHED();
  197. }
  198. if (auto enumerator = consume_token_with_type(TokenType::Enumerator); !enumerator.is_error())
  199. return m_ctx.translation_unit()->get_node_for_enumerator_value(enumerator.value().data);
  200. if (auto number = consume_token_with_type(TokenType::Number); !number.is_error())
  201. return make_ref_counted<MathematicalConstant>(MUST(Crypto::BigFraction::from_string(number.value().data)));
  202. if (auto string = consume_token_with_type(TokenType::String); !string.is_error())
  203. return make_ref_counted<StringLiteral>(string.value().data);
  204. if (auto list_initialization = parse_list_initialization(); !list_initialization.is_error())
  205. return list_initialization.release_value();
  206. if (auto record_initialization = parse_record_direct_list_initialization(); !record_initialization.is_error())
  207. return record_initialization.release_value();
  208. if (auto the_this_value = parse_the_this_value(); !the_this_value.is_error())
  209. return the_this_value.release_value();
  210. return TextParseError {};
  211. }
  212. // <expr>
  213. TextParseErrorOr<Tree> TextParser::parse_expression()
  214. {
  215. auto rollback = rollback_point();
  216. #define THROW_PARSE_ERROR_IF(expr) \
  217. do { \
  218. if (expr) { \
  219. save_error(CustomMessage { "valid expression continuation (not valid because " #expr ")"##sv }); \
  220. return TextParseError {}; \
  221. } \
  222. } while (false)
  223. #define THROW_PARSE_ERROR THROW_PARSE_ERROR_IF(true)
  224. Vector<Variant<Tree, Token>> stack;
  225. auto merge_stack = [&](i32 precedence) {
  226. if (!stack.last().has<Tree>())
  227. return;
  228. while (stack.size() >= 2) {
  229. auto const& maybe_operator = stack[stack.size() - 2];
  230. if (!maybe_operator.has<Token>())
  231. break;
  232. auto last_operator = maybe_operator.get<Token>();
  233. auto right = stack.last().get<Tree>();
  234. if (last_operator.is_unary_operator()) {
  235. auto operation = make_ref_counted<UnaryOperation>(last_operator.as_unary_operator(), right);
  236. stack.shrink(stack.size() - 2);
  237. stack.empend(operation);
  238. } else if (last_operator.is_binary_operator() && last_operator.precedence() < precedence) {
  239. auto left = stack[stack.size() - 3].get<Tree>();
  240. auto operation = make_ref_counted<BinaryOperation>(last_operator.as_binary_operator(), left, right);
  241. stack.shrink(stack.size() - 3);
  242. stack.empend(operation);
  243. } else {
  244. break;
  245. }
  246. }
  247. };
  248. auto merge_pre_merged = [&] {
  249. if (stack.size() < 3)
  250. return;
  251. auto const& maybe_left = stack[stack.size() - 3];
  252. auto const& maybe_operator = stack[stack.size() - 2];
  253. auto const& maybe_right = stack.last();
  254. if (!maybe_left.has<Tree>() || !maybe_operator.has<Token>() || !maybe_right.has<Tree>())
  255. return;
  256. auto last_operator = maybe_operator.get<Token>();
  257. if (!last_operator.is_pre_merged_binary_operator())
  258. return;
  259. auto expression = make_ref_counted<BinaryOperation>(last_operator.as_binary_operator(), maybe_left.get<Tree>(), maybe_right.get<Tree>());
  260. stack.shrink(stack.size() - 3);
  261. stack.empend(expression);
  262. };
  263. i32 bracket_balance = 0;
  264. while (true) {
  265. auto token_or_error = peek_token();
  266. if (!token_or_error.has_value())
  267. break;
  268. auto token = token_or_error.release_value();
  269. bool is_consumed = false;
  270. enum {
  271. NoneType,
  272. ExpressionType,
  273. PreMergedBinaryOperatorType,
  274. UnaryOperatorType,
  275. BinaryOperatorType,
  276. BracketType,
  277. } last_element_type;
  278. if (stack.is_empty())
  279. last_element_type = NoneType;
  280. else if (stack.last().has<Tree>())
  281. last_element_type = ExpressionType;
  282. else if (stack.last().get<Token>().is_pre_merged_binary_operator())
  283. last_element_type = PreMergedBinaryOperatorType;
  284. else if (stack.last().get<Token>().is_unary_operator())
  285. last_element_type = UnaryOperatorType;
  286. else if (stack.last().get<Token>().is_binary_operator())
  287. last_element_type = BinaryOperatorType;
  288. else if (stack.last().get<Token>().is_bracket())
  289. last_element_type = BracketType;
  290. else
  291. VERIFY_NOT_REACHED();
  292. if (token.is_ambiguous_operator()) {
  293. if (token.type == TokenType::AmbiguousMinus)
  294. token.type = last_element_type == ExpressionType ? TokenType::BinaryMinus : TokenType::UnaryMinus;
  295. else
  296. VERIFY_NOT_REACHED();
  297. }
  298. bracket_balance += token.is_opening_bracket();
  299. bracket_balance -= token.is_closing_bracket();
  300. if (bracket_balance < 0)
  301. break;
  302. if (token.type == TokenType::ParenOpen) {
  303. if (last_element_type == ExpressionType) {
  304. // This is a function call.
  305. auto arguments = TRY(parse_function_arguments());
  306. is_consumed = true;
  307. stack.append(Tree { make_ref_counted<FunctionCall>(stack.take_last().get<Tree>(), move(arguments)) });
  308. --bracket_balance;
  309. } else {
  310. // This is just an opening '(' in expression.
  311. stack.append(token);
  312. }
  313. } else if (token.is_pre_merged_binary_operator()) {
  314. THROW_PARSE_ERROR_IF(last_element_type != ExpressionType);
  315. stack.append(token);
  316. } else if (token.is_unary_operator()) {
  317. THROW_PARSE_ERROR_IF(last_element_type == PreMergedBinaryOperatorType);
  318. stack.append(token);
  319. } else if (token.is_binary_operator() || token.is_closing_bracket()) {
  320. if (bracket_balance == 0 && token.type == TokenType::Comma)
  321. break;
  322. THROW_PARSE_ERROR_IF(last_element_type != ExpressionType);
  323. merge_stack(token.precedence());
  324. if (token.is_closing_bracket()) {
  325. THROW_PARSE_ERROR_IF(stack.size() == 1);
  326. THROW_PARSE_ERROR_IF(!stack[stack.size() - 2].get<Token>().matches_with(token));
  327. stack.remove(stack.size() - 2);
  328. merge_pre_merged();
  329. } else {
  330. stack.append(token);
  331. }
  332. } else {
  333. if (auto expression = parse_value(); !expression.is_error()) {
  334. is_consumed = true;
  335. THROW_PARSE_ERROR_IF(last_element_type == ExpressionType);
  336. stack.append(expression.release_value());
  337. merge_pre_merged();
  338. } else {
  339. break;
  340. }
  341. }
  342. if (!is_consumed)
  343. VERIFY(consume_token().has_value());
  344. }
  345. THROW_PARSE_ERROR_IF(stack.is_empty());
  346. merge_stack(closing_bracket_precedence);
  347. THROW_PARSE_ERROR_IF(stack.size() != 1 || !stack[0].has<Tree>());
  348. rollback.disarm();
  349. return stack[0].get<Tree>();
  350. #undef THROW_PARSE_ERROR
  351. #undef THROW_PARSE_ERROR_IF
  352. }
  353. // <condition> :== <expr> | (<expr> is <expr> (or <expr>)?)
  354. TextParseErrorOr<Tree> TextParser::parse_condition()
  355. {
  356. auto rollback = rollback_point();
  357. auto expression = TRY(parse_expression());
  358. if (!consume_token_with_type(TokenType::Is).is_error()) {
  359. Vector compare_values { TRY(parse_expression()) };
  360. if (!consume_word("or"sv).is_error())
  361. compare_values.append(TRY(parse_expression()));
  362. rollback.disarm();
  363. return make_ref_counted<IsOneOfOperation>(expression, move(compare_values));
  364. }
  365. rollback.disarm();
  366. return expression;
  367. }
  368. // return <expr>
  369. TextParseErrorOr<Tree> TextParser::parse_return_statement()
  370. {
  371. auto rollback = rollback_point();
  372. TRY(consume_word("return"sv));
  373. auto return_value = TRY(parse_expression());
  374. rollback.disarm();
  375. return make_ref_counted<ReturnNode>(return_value);
  376. }
  377. // assert: <condition>
  378. TextParseErrorOr<Tree> TextParser::parse_assert()
  379. {
  380. auto rollback = rollback_point();
  381. TRY(consume_token(TokenType::Identifier, "assert"sv));
  382. TRY(consume_token_with_type(TokenType::Colon));
  383. auto condition = TRY(parse_condition());
  384. rollback.disarm();
  385. return make_ref_counted<AssertExpression>(condition);
  386. }
  387. // (let <expr> be <expr>) | (set <expr> to <expr>)
  388. TextParseErrorOr<Tree> TextParser::parse_assignment()
  389. {
  390. auto rollback = rollback_point();
  391. bool is_let = !consume_word("let"sv).is_error();
  392. if (!is_let)
  393. TRY(consume_word("set"sv));
  394. auto lvalue = TRY(parse_expression());
  395. TRY(consume_word(is_let ? "be"sv : "to"sv));
  396. auto rvalue = TRY(parse_expression());
  397. rollback.disarm();
  398. auto op = is_let ? BinaryOperator::Declaration : BinaryOperator::Assignment;
  399. return make_ref_counted<BinaryOperation>(op, lvalue, rvalue);
  400. }
  401. // perform <expr>
  402. TextParseErrorOr<Tree> TextParser::parse_perform()
  403. {
  404. auto rollback = rollback_point();
  405. TRY(consume_word("perform"sv));
  406. auto value = TRY(parse_expression());
  407. rollback.disarm();
  408. return value;
  409. }
  410. // <simple_step>
  411. TextParseErrorOr<Tree> TextParser::parse_simple_step_or_inline_if_branch()
  412. {
  413. auto rollback = rollback_point();
  414. // Return <expr>.$
  415. if (auto result = parse_return_statement(); !result.is_error()) {
  416. TRY(consume_token_with_type(TokenType::Dot));
  417. TRY(expect_eof());
  418. rollback.disarm();
  419. return result.release_value();
  420. }
  421. // Assert: <expr>.$
  422. if (auto result = parse_assert(); !result.is_error()) {
  423. TRY(consume_token_with_type(TokenType::Dot));
  424. TRY(expect_eof());
  425. rollback.disarm();
  426. return result.release_value();
  427. }
  428. // Let <expr> be <expr>.$
  429. // Set <expr> to <expr>.$
  430. if (auto result = parse_assignment(); !result.is_error()) {
  431. TRY(consume_token_with_type(TokenType::Dot));
  432. TRY(expect_eof());
  433. rollback.disarm();
  434. return result.release_value();
  435. }
  436. // Perform <expr>.$
  437. if (auto result = parse_perform(); !result.is_error()) {
  438. TRY(consume_token_with_type(TokenType::Dot));
  439. TRY(expect_eof());
  440. rollback.disarm();
  441. return result.release_value();
  442. }
  443. return TextParseError {};
  444. }
  445. // <if_condition> :== (If <condition>) | (Else) | (Else if <condition>),
  446. TextParseErrorOr<TextParser::IfConditionParseResult> TextParser::parse_if_beginning()
  447. {
  448. auto rollback = rollback_point();
  449. bool is_if_branch = !consume_word("if"sv).is_error();
  450. NullableTree condition = nullptr;
  451. if (is_if_branch) {
  452. condition = TRY(parse_condition());
  453. } else {
  454. TRY(consume_word("else"sv));
  455. if (!consume_word("if"sv).is_error())
  456. condition = TRY(parse_condition());
  457. }
  458. TRY(consume_token_with_type(TokenType::Comma));
  459. rollback.disarm();
  460. return IfConditionParseResult { is_if_branch, condition };
  461. }
  462. // <inline_if> :== <if_condition> <simple_step>.$
  463. TextParseErrorOr<Tree> TextParser::parse_inline_if_else()
  464. {
  465. auto rollback = rollback_point();
  466. auto [is_if_branch, condition] = TRY(parse_if_beginning());
  467. auto then_branch = TRY(parse_simple_step_or_inline_if_branch());
  468. rollback.disarm();
  469. if (is_if_branch)
  470. return make_ref_counted<IfBranch>(condition.release_nonnull(), then_branch);
  471. return make_ref_counted<ElseIfBranch>(condition, then_branch);
  472. }
  473. // <if> :== <if_condition> then$ <substeps>
  474. TextParseErrorOr<Tree> TextParser::parse_if(Tree then_branch)
  475. {
  476. auto rollback = rollback_point();
  477. auto [is_if_branch, condition] = TRY(parse_if_beginning());
  478. TRY(consume_word("then"sv));
  479. TRY(expect_eof());
  480. rollback.disarm();
  481. if (is_if_branch)
  482. return make_ref_counted<IfBranch>(*condition, then_branch);
  483. else
  484. return make_ref_counted<ElseIfBranch>(condition, then_branch);
  485. }
  486. // <else> :== Else,$ <substeps>
  487. TextParseErrorOr<Tree> TextParser::parse_else(Tree else_branch)
  488. {
  489. auto rollback = rollback_point();
  490. TRY(consume_word("else"sv));
  491. TRY(consume_token_with_type(TokenType::Comma));
  492. TRY(expect_eof());
  493. rollback.disarm();
  494. return make_ref_counted<ElseIfBranch>(nullptr, else_branch);
  495. }
  496. // <simple_step> | <inline_if>
  497. TextParseErrorOr<NullableTree> TextParser::parse_step_without_substeps()
  498. {
  499. auto rollback = rollback_point();
  500. // NOTE: ...
  501. if (auto result = consume_word("NOTE:"sv); !result.is_error()) {
  502. rollback.disarm();
  503. return nullptr;
  504. }
  505. // <simple_step>
  506. if (auto result = parse_simple_step_or_inline_if_branch(); !result.is_error()) {
  507. rollback.disarm();
  508. return result.release_value();
  509. }
  510. // <inline_if>
  511. if (auto result = parse_inline_if_else(); !result.is_error()) {
  512. rollback.disarm();
  513. return result.release_value();
  514. }
  515. return TextParseError {};
  516. }
  517. // <if> | <else>
  518. TextParseErrorOr<Tree> TextParser::parse_step_with_substeps(Tree substeps)
  519. {
  520. auto rollback = rollback_point();
  521. // <if>
  522. if (auto result = parse_if(substeps); !result.is_error()) {
  523. rollback.disarm();
  524. return result.release_value();
  525. }
  526. // <else>
  527. if (auto result = parse_else(substeps); !result.is_error()) {
  528. rollback.disarm();
  529. return result.release_value();
  530. }
  531. return TextParseError {};
  532. }
  533. // <qualified_name> :== <word> (. <word>)*
  534. TextParseErrorOr<Vector<StringView>> TextParser::parse_qualified_name()
  535. {
  536. Vector<StringView> qualified_name;
  537. qualified_name.append(TRY(consume_token_with_type(TokenType::Word)).data);
  538. while (true) {
  539. auto token_or_error = consume_token_with_type(TokenType::MemberAccess);
  540. if (token_or_error.is_error())
  541. return qualified_name;
  542. qualified_name.append(TRY(consume_token_with_type(TokenType::Word)).data);
  543. }
  544. }
  545. // <function_arguments> :== '(' (<word> (, <word>)*)? ')'
  546. TextParseErrorOr<Vector<FunctionArgument>> TextParser::parse_function_arguments_in_declaration()
  547. {
  548. TRY(consume_token_with_type(TokenType::ParenOpen));
  549. Vector<FunctionArgument> arguments;
  550. size_t optional_arguments_group = 0;
  551. while (true) {
  552. Token token = TRY(consume_token_with_one_of_types({
  553. TokenType::SquareBracketOpen,
  554. arguments.is_empty() ? TokenType::Identifier : TokenType::Comma,
  555. !optional_arguments_group ? TokenType::ParenClose : TokenType::Invalid,
  556. optional_arguments_group ? TokenType::SquareBracketClose : TokenType::Invalid,
  557. }));
  558. StringView identifier;
  559. if (token.type == TokenType::SquareBracketClose) {
  560. VERIFY(optional_arguments_group != 0);
  561. for (size_t i = 1; i < optional_arguments_group; ++i)
  562. TRY(consume_token_with_type(TokenType::SquareBracketClose));
  563. TRY(consume_token_with_type(TokenType::ParenClose));
  564. break;
  565. } else if (token.type == TokenType::ParenClose) {
  566. VERIFY(optional_arguments_group == 0);
  567. break;
  568. } else if (token.type == TokenType::SquareBracketOpen) {
  569. ++optional_arguments_group;
  570. if (!arguments.is_empty())
  571. TRY(consume_token_with_type(TokenType::Comma));
  572. identifier = TRY(consume_token_with_type(TokenType::Identifier)).data;
  573. } else if (token.type == TokenType::Comma) {
  574. identifier = TRY(consume_token_with_type(TokenType::Identifier)).data;
  575. } else {
  576. VERIFY(token.type == TokenType::Identifier);
  577. identifier = token.data;
  578. }
  579. arguments.append({ identifier, optional_arguments_group });
  580. }
  581. return arguments;
  582. }
  583. // <ao_declaration> :== <word> <function_arguments> $
  584. TextParseErrorOr<ClauseHeader::AbstractOperation> TextParser::parse_abstract_operation_declaration()
  585. {
  586. auto rollback = rollback_point();
  587. ClauseHeader::AbstractOperation function_definition;
  588. function_definition.name = TRY(consume_token_with_type(TokenType::Word)).data;
  589. function_definition.arguments = TRY(parse_function_arguments_in_declaration());
  590. TRY(expect_eof());
  591. rollback.disarm();
  592. return function_definition;
  593. }
  594. // <accessor_declaration> :== get <qualified_name> $
  595. TextParseErrorOr<ClauseHeader::Accessor> TextParser::parse_accessor_declaration()
  596. {
  597. auto rollback = rollback_point();
  598. TRY(consume_word("get"sv));
  599. ClauseHeader::Accessor accessor;
  600. accessor.qualified_name = TRY(parse_qualified_name());
  601. TRY(expect_eof());
  602. rollback.disarm();
  603. return accessor;
  604. }
  605. TextParseErrorOr<ClauseHeader::Method> TextParser::parse_method_declaration()
  606. {
  607. auto rollback = rollback_point();
  608. ClauseHeader::Method method;
  609. method.qualified_name = TRY(parse_qualified_name());
  610. method.arguments = TRY(parse_function_arguments_in_declaration());
  611. TRY(expect_eof());
  612. rollback.disarm();
  613. return method;
  614. }
  615. // <clause_header> :== <section_number> <ao_declaration> | <accessor_declaration>
  616. TextParseErrorOr<ClauseHeader> TextParser::parse_clause_header(ClauseHasAoidAttribute clause_has_aoid_attribute)
  617. {
  618. ClauseHeader result;
  619. auto section_number_token = TRY(consume_token_with_type(TokenType::SectionNumber));
  620. result.section_number = section_number_token.data;
  621. if (clause_has_aoid_attribute == ClauseHasAoidAttribute::Yes) {
  622. if (auto ao_declaration = parse_abstract_operation_declaration(); !ao_declaration.is_error()) {
  623. result.header = ao_declaration.release_value();
  624. return result;
  625. }
  626. } else {
  627. if (auto accessor = parse_accessor_declaration(); !accessor.is_error()) {
  628. result.header = accessor.release_value();
  629. return result;
  630. } else if (auto method = parse_method_declaration(); !method.is_error()) {
  631. result.header = method.release_value();
  632. return result;
  633. }
  634. }
  635. return TextParseError {};
  636. }
  637. FailedTextParseDiagnostic TextParser::get_diagnostic() const
  638. {
  639. StringBuilder message;
  640. message.append("unexpected "sv);
  641. if (m_max_parsed_tokens == m_tokens.size()) {
  642. message.append("EOF"sv);
  643. } else {
  644. auto token = m_tokens[m_max_parsed_tokens];
  645. if (token.type == TokenType::Word)
  646. message.appendff("'{}'", token.data);
  647. else if (token.type == TokenType::Identifier)
  648. message.appendff("identifier '{}'", token.data);
  649. else
  650. message.append(token.name_for_diagnostic());
  651. }
  652. message.appendff(", expected ");
  653. size_t size = m_suitable_continuations.size();
  654. VERIFY(size > 0);
  655. for (size_t i = 0; i < size; ++i) {
  656. m_suitable_continuations[i].visit(
  657. [&](TokenType type) { message.append(token_info[to_underlying(type)].name_for_diagnostic); },
  658. [&](StringView word) { message.appendff("'{}'", word); },
  659. [&](CustomMessage continuation) { message.append(continuation.message); });
  660. if (i + 1 != size) {
  661. if (size == 2)
  662. message.append(" or "sv);
  663. else if (i + 2 == size)
  664. message.append(", or "sv);
  665. else
  666. message.append(", "sv);
  667. }
  668. }
  669. Location location = Location::global_scope();
  670. if (m_max_parsed_tokens < m_tokens.size()) {
  671. location = m_tokens[m_max_parsed_tokens].location;
  672. } else {
  673. // FIXME: Would be nice to point to the closing tag not the opening one. This is also the
  674. // only place where we use m_location.
  675. location = m_ctx.location_from_xml_offset(m_node->offset);
  676. }
  677. return { location, MUST(message.to_string()) };
  678. }
  679. }