ASTCodegen.cpp 127 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556255725582559256025612562256325642565256625672568256925702571257225732574257525762577257825792580258125822583258425852586258725882589259025912592259325942595259625972598259926002601260226032604260526062607260826092610261126122613261426152616261726182619262026212622262326242625262626272628262926302631263226332634263526362637263826392640264126422643264426452646264726482649265026512652265326542655265626572658265926602661266226632664266526662667266826692670267126722673267426752676267726782679268026812682268326842685268626872688268926902691269226932694269526962697269826992700270127022703270427052706270727082709271027112712271327142715271627172718271927202721272227232724272527262727272827292730273127322733273427352736273727382739274027412742274327442745274627472748274927502751275227532754275527562757275827592760276127622763276427652766276727682769277027712772277327742775277627772778277927802781278227832784278527862787278827892790279127922793279427952796279727982799280028012802280328042805280628072808280928102811281228132814281528162817281828192820282128222823282428252826282728282829283028312832283328342835283628372838283928402841284228432844284528462847284828492850285128522853285428552856285728582859286028612862286328642865286628672868286928702871287228732874287528762877287828792880
  1. /*
  2. * Copyright (c) 2021-2023, Andreas Kling <kling@serenityos.org>
  3. * Copyright (c) 2021, Linus Groh <linusg@serenityos.org>
  4. * Copyright (c) 2021, Gunnar Beutner <gbeutner@serenityos.org>
  5. * Copyright (c) 2021, Marcin Gasperowicz <xnooga@gmail.com>
  6. *
  7. * SPDX-License-Identifier: BSD-2-Clause
  8. */
  9. #include <AK/Find.h>
  10. #include <LibJS/AST.h>
  11. #include <LibJS/Bytecode/Generator.h>
  12. #include <LibJS/Bytecode/Instruction.h>
  13. #include <LibJS/Bytecode/Op.h>
  14. #include <LibJS/Bytecode/Register.h>
  15. #include <LibJS/Bytecode/StringTable.h>
  16. #include <LibJS/Runtime/Environment.h>
  17. #include <LibJS/Runtime/ErrorTypes.h>
  18. namespace JS {
  19. Bytecode::CodeGenerationErrorOr<void> ASTNode::generate_bytecode(Bytecode::Generator&) const
  20. {
  21. return Bytecode::CodeGenerationError {
  22. this,
  23. "Missing generate_bytecode()"sv,
  24. };
  25. }
  26. Bytecode::CodeGenerationErrorOr<void> ScopeNode::generate_bytecode(Bytecode::Generator& generator) const
  27. {
  28. bool did_create_lexical_environment = false;
  29. if (is<BlockStatement>(*this)) {
  30. if (has_lexical_declarations()) {
  31. generator.block_declaration_instantiation(*this);
  32. did_create_lexical_environment = true;
  33. }
  34. } else if (is<Program>(*this)) {
  35. // GlobalDeclarationInstantiation is handled by the C++ AO.
  36. } else {
  37. // FunctionDeclarationInstantiation is handled by the C++ AO.
  38. }
  39. for (auto& child : children()) {
  40. TRY(child->generate_bytecode(generator));
  41. if (generator.is_current_block_terminated())
  42. break;
  43. }
  44. if (did_create_lexical_environment)
  45. generator.end_variable_scope();
  46. return {};
  47. }
  48. Bytecode::CodeGenerationErrorOr<void> EmptyStatement::generate_bytecode(Bytecode::Generator&) const
  49. {
  50. return {};
  51. }
  52. Bytecode::CodeGenerationErrorOr<void> ExpressionStatement::generate_bytecode(Bytecode::Generator& generator) const
  53. {
  54. return m_expression->generate_bytecode(generator);
  55. }
  56. Bytecode::CodeGenerationErrorOr<void> BinaryExpression::generate_bytecode(Bytecode::Generator& generator) const
  57. {
  58. TRY(m_lhs->generate_bytecode(generator));
  59. auto lhs_reg = generator.allocate_register();
  60. generator.emit<Bytecode::Op::Store>(lhs_reg);
  61. TRY(m_rhs->generate_bytecode(generator));
  62. switch (m_op) {
  63. case BinaryOp::Addition:
  64. generator.emit<Bytecode::Op::Add>(lhs_reg);
  65. break;
  66. case BinaryOp::Subtraction:
  67. generator.emit<Bytecode::Op::Sub>(lhs_reg);
  68. break;
  69. case BinaryOp::Multiplication:
  70. generator.emit<Bytecode::Op::Mul>(lhs_reg);
  71. break;
  72. case BinaryOp::Division:
  73. generator.emit<Bytecode::Op::Div>(lhs_reg);
  74. break;
  75. case BinaryOp::Modulo:
  76. generator.emit<Bytecode::Op::Mod>(lhs_reg);
  77. break;
  78. case BinaryOp::Exponentiation:
  79. generator.emit<Bytecode::Op::Exp>(lhs_reg);
  80. break;
  81. case BinaryOp::GreaterThan:
  82. generator.emit<Bytecode::Op::GreaterThan>(lhs_reg);
  83. break;
  84. case BinaryOp::GreaterThanEquals:
  85. generator.emit<Bytecode::Op::GreaterThanEquals>(lhs_reg);
  86. break;
  87. case BinaryOp::LessThan:
  88. generator.emit<Bytecode::Op::LessThan>(lhs_reg);
  89. break;
  90. case BinaryOp::LessThanEquals:
  91. generator.emit<Bytecode::Op::LessThanEquals>(lhs_reg);
  92. break;
  93. case BinaryOp::LooselyInequals:
  94. generator.emit<Bytecode::Op::LooselyInequals>(lhs_reg);
  95. break;
  96. case BinaryOp::LooselyEquals:
  97. generator.emit<Bytecode::Op::LooselyEquals>(lhs_reg);
  98. break;
  99. case BinaryOp::StrictlyInequals:
  100. generator.emit<Bytecode::Op::StrictlyInequals>(lhs_reg);
  101. break;
  102. case BinaryOp::StrictlyEquals:
  103. generator.emit<Bytecode::Op::StrictlyEquals>(lhs_reg);
  104. break;
  105. case BinaryOp::BitwiseAnd:
  106. generator.emit<Bytecode::Op::BitwiseAnd>(lhs_reg);
  107. break;
  108. case BinaryOp::BitwiseOr:
  109. generator.emit<Bytecode::Op::BitwiseOr>(lhs_reg);
  110. break;
  111. case BinaryOp::BitwiseXor:
  112. generator.emit<Bytecode::Op::BitwiseXor>(lhs_reg);
  113. break;
  114. case BinaryOp::LeftShift:
  115. generator.emit<Bytecode::Op::LeftShift>(lhs_reg);
  116. break;
  117. case BinaryOp::RightShift:
  118. generator.emit<Bytecode::Op::RightShift>(lhs_reg);
  119. break;
  120. case BinaryOp::UnsignedRightShift:
  121. generator.emit<Bytecode::Op::UnsignedRightShift>(lhs_reg);
  122. break;
  123. case BinaryOp::In:
  124. generator.emit<Bytecode::Op::In>(lhs_reg);
  125. break;
  126. case BinaryOp::InstanceOf:
  127. generator.emit<Bytecode::Op::InstanceOf>(lhs_reg);
  128. break;
  129. default:
  130. VERIFY_NOT_REACHED();
  131. }
  132. return {};
  133. }
  134. Bytecode::CodeGenerationErrorOr<void> LogicalExpression::generate_bytecode(Bytecode::Generator& generator) const
  135. {
  136. TRY(m_lhs->generate_bytecode(generator));
  137. // lhs
  138. // jump op (true) end (false) rhs
  139. // rhs
  140. // jump always (true) end
  141. // end
  142. auto& rhs_block = generator.make_block();
  143. auto& end_block = generator.make_block();
  144. switch (m_op) {
  145. case LogicalOp::And:
  146. generator.emit<Bytecode::Op::JumpConditional>().set_targets(
  147. Bytecode::Label { rhs_block },
  148. Bytecode::Label { end_block });
  149. break;
  150. case LogicalOp::Or:
  151. generator.emit<Bytecode::Op::JumpConditional>().set_targets(
  152. Bytecode::Label { end_block },
  153. Bytecode::Label { rhs_block });
  154. break;
  155. case LogicalOp::NullishCoalescing:
  156. generator.emit<Bytecode::Op::JumpNullish>().set_targets(
  157. Bytecode::Label { rhs_block },
  158. Bytecode::Label { end_block });
  159. break;
  160. default:
  161. VERIFY_NOT_REACHED();
  162. }
  163. generator.switch_to_basic_block(rhs_block);
  164. TRY(m_rhs->generate_bytecode(generator));
  165. generator.emit<Bytecode::Op::Jump>().set_targets(
  166. Bytecode::Label { end_block },
  167. {});
  168. generator.switch_to_basic_block(end_block);
  169. return {};
  170. }
  171. Bytecode::CodeGenerationErrorOr<void> UnaryExpression::generate_bytecode(Bytecode::Generator& generator) const
  172. {
  173. if (m_op == UnaryOp::Delete)
  174. return generator.emit_delete_reference(m_lhs);
  175. // Typeof needs some special handling for when the LHS is an Identifier. Namely, it shouldn't throw on unresolvable references, but instead return "undefined".
  176. if (m_op != UnaryOp::Typeof)
  177. TRY(m_lhs->generate_bytecode(generator));
  178. switch (m_op) {
  179. case UnaryOp::BitwiseNot:
  180. generator.emit<Bytecode::Op::BitwiseNot>();
  181. break;
  182. case UnaryOp::Not:
  183. generator.emit<Bytecode::Op::Not>();
  184. break;
  185. case UnaryOp::Plus:
  186. generator.emit<Bytecode::Op::UnaryPlus>();
  187. break;
  188. case UnaryOp::Minus:
  189. generator.emit<Bytecode::Op::UnaryMinus>();
  190. break;
  191. case UnaryOp::Typeof:
  192. if (is<Identifier>(*m_lhs)) {
  193. auto& identifier = static_cast<Identifier const&>(*m_lhs);
  194. generator.emit<Bytecode::Op::TypeofVariable>(generator.intern_identifier(identifier.string()));
  195. break;
  196. }
  197. TRY(m_lhs->generate_bytecode(generator));
  198. generator.emit<Bytecode::Op::Typeof>();
  199. break;
  200. case UnaryOp::Void:
  201. generator.emit<Bytecode::Op::LoadImmediate>(js_undefined());
  202. break;
  203. case UnaryOp::Delete: // Delete is implemented above.
  204. default:
  205. VERIFY_NOT_REACHED();
  206. }
  207. return {};
  208. }
  209. Bytecode::CodeGenerationErrorOr<void> NumericLiteral::generate_bytecode(Bytecode::Generator& generator) const
  210. {
  211. generator.emit<Bytecode::Op::LoadImmediate>(m_value);
  212. return {};
  213. }
  214. Bytecode::CodeGenerationErrorOr<void> BooleanLiteral::generate_bytecode(Bytecode::Generator& generator) const
  215. {
  216. generator.emit<Bytecode::Op::LoadImmediate>(Value(m_value));
  217. return {};
  218. }
  219. Bytecode::CodeGenerationErrorOr<void> NullLiteral::generate_bytecode(Bytecode::Generator& generator) const
  220. {
  221. generator.emit<Bytecode::Op::LoadImmediate>(js_null());
  222. return {};
  223. }
  224. Bytecode::CodeGenerationErrorOr<void> BigIntLiteral::generate_bytecode(Bytecode::Generator& generator) const
  225. {
  226. // 1. Return the NumericValue of NumericLiteral as defined in 12.8.3.
  227. auto integer = [&] {
  228. if (m_value[0] == '0' && m_value.length() >= 3)
  229. if (m_value[1] == 'x' || m_value[1] == 'X')
  230. return Crypto::SignedBigInteger::from_base(16, m_value.substring(2, m_value.length() - 3));
  231. if (m_value[1] == 'o' || m_value[1] == 'O')
  232. return Crypto::SignedBigInteger::from_base(8, m_value.substring(2, m_value.length() - 3));
  233. if (m_value[1] == 'b' || m_value[1] == 'B')
  234. return Crypto::SignedBigInteger::from_base(2, m_value.substring(2, m_value.length() - 3));
  235. return Crypto::SignedBigInteger::from_base(10, m_value.substring(0, m_value.length() - 1));
  236. }();
  237. generator.emit<Bytecode::Op::NewBigInt>(integer);
  238. return {};
  239. }
  240. Bytecode::CodeGenerationErrorOr<void> StringLiteral::generate_bytecode(Bytecode::Generator& generator) const
  241. {
  242. generator.emit<Bytecode::Op::NewString>(generator.intern_string(m_value));
  243. return {};
  244. }
  245. Bytecode::CodeGenerationErrorOr<void> RegExpLiteral::generate_bytecode(Bytecode::Generator& generator) const
  246. {
  247. auto source_index = generator.intern_string(m_pattern);
  248. auto flags_index = generator.intern_string(m_flags);
  249. generator.emit<Bytecode::Op::NewRegExp>(source_index, flags_index);
  250. return {};
  251. }
  252. Bytecode::CodeGenerationErrorOr<void> Identifier::generate_bytecode(Bytecode::Generator& generator) const
  253. {
  254. generator.emit<Bytecode::Op::GetVariable>(generator.intern_identifier(m_string));
  255. return {};
  256. }
  257. static Bytecode::CodeGenerationErrorOr<void> arguments_to_array_for_call(Bytecode::Generator& generator, ReadonlySpan<CallExpression::Argument> arguments)
  258. {
  259. if (arguments.is_empty()) {
  260. generator.emit<Bytecode::Op::NewArray>();
  261. return {};
  262. }
  263. auto first_spread = find_if(arguments.begin(), arguments.end(), [](auto el) { return el.is_spread; });
  264. Bytecode::Register args_start_reg { 0 };
  265. for (auto it = arguments.begin(); it != first_spread; ++it) {
  266. auto reg = generator.allocate_register();
  267. if (args_start_reg.index() == 0)
  268. args_start_reg = reg;
  269. }
  270. u32 i = 0;
  271. for (auto it = arguments.begin(); it != first_spread; ++it, ++i) {
  272. VERIFY(it->is_spread == false);
  273. Bytecode::Register reg { args_start_reg.index() + i };
  274. TRY(it->value->generate_bytecode(generator));
  275. generator.emit<Bytecode::Op::Store>(reg);
  276. }
  277. if (first_spread.index() != 0)
  278. generator.emit_with_extra_register_slots<Bytecode::Op::NewArray>(2u, AK::Array { args_start_reg, Bytecode::Register { args_start_reg.index() + static_cast<u32>(first_spread.index() - 1) } });
  279. else
  280. generator.emit<Bytecode::Op::NewArray>();
  281. if (first_spread != arguments.end()) {
  282. auto array_reg = generator.allocate_register();
  283. generator.emit<Bytecode::Op::Store>(array_reg);
  284. for (auto it = first_spread; it != arguments.end(); ++it) {
  285. TRY(it->value->generate_bytecode(generator));
  286. generator.emit<Bytecode::Op::Append>(array_reg, it->is_spread);
  287. }
  288. generator.emit<Bytecode::Op::Load>(array_reg);
  289. }
  290. return {};
  291. }
  292. Bytecode::CodeGenerationErrorOr<void> SuperCall::generate_bytecode(Bytecode::Generator& generator) const
  293. {
  294. if (m_is_synthetic == IsPartOfSyntheticConstructor::Yes) {
  295. // NOTE: This is the case where we have a fake constructor(...args) { super(...args); } which
  296. // shouldn't call @@iterator of %Array.prototype%.
  297. VERIFY(m_arguments.size() == 1);
  298. VERIFY(m_arguments[0].is_spread);
  299. auto const& argument = m_arguments[0];
  300. // This generates a single argument, which will be implicitly passed in accumulator
  301. MUST(argument.value->generate_bytecode(generator));
  302. } else {
  303. TRY(arguments_to_array_for_call(generator, m_arguments));
  304. }
  305. generator.emit<Bytecode::Op::SuperCall>(m_is_synthetic == IsPartOfSyntheticConstructor::Yes);
  306. return {};
  307. }
  308. static Bytecode::CodeGenerationErrorOr<void> generate_binding_pattern_bytecode(Bytecode::Generator& generator, BindingPattern const& pattern, Bytecode::Op::SetVariable::InitializationMode, Bytecode::Register const& value_reg, bool create_variables);
  309. Bytecode::CodeGenerationErrorOr<void> AssignmentExpression::generate_bytecode(Bytecode::Generator& generator) const
  310. {
  311. if (m_op == AssignmentOp::Assignment) {
  312. // AssignmentExpression : LeftHandSideExpression = AssignmentExpression
  313. return m_lhs.visit(
  314. // 1. If LeftHandSideExpression is neither an ObjectLiteral nor an ArrayLiteral, then
  315. [&](NonnullRefPtr<Expression const> const& lhs) -> Bytecode::CodeGenerationErrorOr<void> {
  316. // a. Let lref be the result of evaluating LeftHandSideExpression.
  317. // b. ReturnIfAbrupt(lref).
  318. Optional<Bytecode::Register> base_object_register;
  319. Optional<Bytecode::Register> computed_property_register;
  320. if (is<MemberExpression>(*lhs)) {
  321. auto& expression = static_cast<MemberExpression const&>(*lhs);
  322. TRY(expression.object().generate_bytecode(generator));
  323. base_object_register = generator.allocate_register();
  324. generator.emit<Bytecode::Op::Store>(*base_object_register);
  325. if (expression.is_computed()) {
  326. TRY(expression.property().generate_bytecode(generator));
  327. computed_property_register = generator.allocate_register();
  328. generator.emit<Bytecode::Op::Store>(*computed_property_register);
  329. // To be continued later with PutByValue.
  330. } else if (expression.property().is_identifier()) {
  331. // Do nothing, this will be handled by PutById later.
  332. } else if (expression.property().is_private_identifier()) {
  333. // Do nothing, this will be handled by PutPrivateById later.
  334. } else {
  335. return Bytecode::CodeGenerationError {
  336. &expression,
  337. "Unimplemented non-computed member expression"sv
  338. };
  339. }
  340. } else if (is<Identifier>(*lhs)) {
  341. // NOTE: For Identifiers, we cannot perform GetVariable and then write into the reference it retrieves, only SetVariable can do this.
  342. // FIXME: However, this breaks spec as we are doing variable lookup after evaluating the RHS. This is observable in an object environment, where we visibly perform HasOwnProperty and Get(@@unscopables) on the binded object.
  343. } else {
  344. TRY(lhs->generate_bytecode(generator));
  345. }
  346. // FIXME: c. If IsAnonymousFunctionDefinition(AssignmentExpression) and IsIdentifierRef of LeftHandSideExpression are both true, then
  347. // i. Let rval be ? NamedEvaluation of AssignmentExpression with argument lref.[[ReferencedName]].
  348. // d. Else,
  349. // i. Let rref be the result of evaluating AssignmentExpression.
  350. // ii. Let rval be ? GetValue(rref).
  351. if (lhs->is_identifier()) {
  352. TRY(generator.emit_named_evaluation_if_anonymous_function(*m_rhs, static_cast<Identifier const&>(*lhs).string()));
  353. } else {
  354. TRY(m_rhs->generate_bytecode(generator));
  355. }
  356. // e. Perform ? PutValue(lref, rval).
  357. if (is<Identifier>(*lhs)) {
  358. auto& identifier = static_cast<Identifier const&>(*lhs);
  359. generator.emit<Bytecode::Op::SetVariable>(generator.intern_identifier(identifier.string()));
  360. } else if (is<MemberExpression>(*lhs)) {
  361. auto& expression = static_cast<MemberExpression const&>(*lhs);
  362. if (expression.is_computed()) {
  363. generator.emit<Bytecode::Op::PutByValue>(*base_object_register, *computed_property_register);
  364. } else if (expression.property().is_identifier()) {
  365. auto identifier_table_ref = generator.intern_identifier(verify_cast<Identifier>(expression.property()).string());
  366. generator.emit<Bytecode::Op::PutById>(*base_object_register, identifier_table_ref);
  367. } else if (expression.property().is_private_identifier()) {
  368. auto identifier_table_ref = generator.intern_identifier(verify_cast<PrivateIdentifier>(expression.property()).string());
  369. generator.emit<Bytecode::Op::PutPrivateById>(*base_object_register, identifier_table_ref);
  370. } else {
  371. return Bytecode::CodeGenerationError {
  372. &expression,
  373. "Unimplemented non-computed member expression"sv
  374. };
  375. }
  376. } else {
  377. return Bytecode::CodeGenerationError {
  378. lhs,
  379. "Unimplemented/invalid node used a reference"sv
  380. };
  381. }
  382. // f. Return rval.
  383. // NOTE: This is already in the accumulator.
  384. return {};
  385. },
  386. // 2. Let assignmentPattern be the AssignmentPattern that is covered by LeftHandSideExpression.
  387. [&](NonnullRefPtr<BindingPattern const> const& pattern) -> Bytecode::CodeGenerationErrorOr<void> {
  388. // 3. Let rref be the result of evaluating AssignmentExpression.
  389. // 4. Let rval be ? GetValue(rref).
  390. TRY(m_rhs->generate_bytecode(generator));
  391. auto value_register = generator.allocate_register();
  392. generator.emit<Bytecode::Op::Store>(value_register);
  393. // 5. Perform ? DestructuringAssignmentEvaluation of assignmentPattern with argument rval.
  394. TRY(generate_binding_pattern_bytecode(generator, pattern, Bytecode::Op::SetVariable::InitializationMode::Set, value_register, false));
  395. // 6. Return rval.
  396. generator.emit<Bytecode::Op::Load>(value_register);
  397. return {};
  398. });
  399. }
  400. VERIFY(m_lhs.has<NonnullRefPtr<Expression const>>());
  401. auto& lhs = m_lhs.get<NonnullRefPtr<Expression const>>();
  402. TRY(generator.emit_load_from_reference(lhs));
  403. Bytecode::BasicBlock* rhs_block_ptr { nullptr };
  404. Bytecode::BasicBlock* end_block_ptr { nullptr };
  405. // Logical assignments short circuit.
  406. if (m_op == AssignmentOp::AndAssignment) { // &&=
  407. rhs_block_ptr = &generator.make_block();
  408. end_block_ptr = &generator.make_block();
  409. generator.emit<Bytecode::Op::JumpConditional>().set_targets(
  410. Bytecode::Label { *rhs_block_ptr },
  411. Bytecode::Label { *end_block_ptr });
  412. } else if (m_op == AssignmentOp::OrAssignment) { // ||=
  413. rhs_block_ptr = &generator.make_block();
  414. end_block_ptr = &generator.make_block();
  415. generator.emit<Bytecode::Op::JumpConditional>().set_targets(
  416. Bytecode::Label { *end_block_ptr },
  417. Bytecode::Label { *rhs_block_ptr });
  418. } else if (m_op == AssignmentOp::NullishAssignment) { // ??=
  419. rhs_block_ptr = &generator.make_block();
  420. end_block_ptr = &generator.make_block();
  421. generator.emit<Bytecode::Op::JumpNullish>().set_targets(
  422. Bytecode::Label { *rhs_block_ptr },
  423. Bytecode::Label { *end_block_ptr });
  424. }
  425. if (rhs_block_ptr)
  426. generator.switch_to_basic_block(*rhs_block_ptr);
  427. // lhs_reg is a part of the rhs_block because the store isn't necessary
  428. // if the logical assignment condition fails.
  429. auto lhs_reg = generator.allocate_register();
  430. generator.emit<Bytecode::Op::Store>(lhs_reg);
  431. if (lhs->is_identifier())
  432. TRY(generator.emit_named_evaluation_if_anonymous_function(*m_rhs, static_cast<Identifier const&>(*lhs).string()));
  433. else
  434. TRY(m_rhs->generate_bytecode(generator));
  435. switch (m_op) {
  436. case AssignmentOp::AdditionAssignment:
  437. generator.emit<Bytecode::Op::Add>(lhs_reg);
  438. break;
  439. case AssignmentOp::SubtractionAssignment:
  440. generator.emit<Bytecode::Op::Sub>(lhs_reg);
  441. break;
  442. case AssignmentOp::MultiplicationAssignment:
  443. generator.emit<Bytecode::Op::Mul>(lhs_reg);
  444. break;
  445. case AssignmentOp::DivisionAssignment:
  446. generator.emit<Bytecode::Op::Div>(lhs_reg);
  447. break;
  448. case AssignmentOp::ModuloAssignment:
  449. generator.emit<Bytecode::Op::Mod>(lhs_reg);
  450. break;
  451. case AssignmentOp::ExponentiationAssignment:
  452. generator.emit<Bytecode::Op::Exp>(lhs_reg);
  453. break;
  454. case AssignmentOp::BitwiseAndAssignment:
  455. generator.emit<Bytecode::Op::BitwiseAnd>(lhs_reg);
  456. break;
  457. case AssignmentOp::BitwiseOrAssignment:
  458. generator.emit<Bytecode::Op::BitwiseOr>(lhs_reg);
  459. break;
  460. case AssignmentOp::BitwiseXorAssignment:
  461. generator.emit<Bytecode::Op::BitwiseXor>(lhs_reg);
  462. break;
  463. case AssignmentOp::LeftShiftAssignment:
  464. generator.emit<Bytecode::Op::LeftShift>(lhs_reg);
  465. break;
  466. case AssignmentOp::RightShiftAssignment:
  467. generator.emit<Bytecode::Op::RightShift>(lhs_reg);
  468. break;
  469. case AssignmentOp::UnsignedRightShiftAssignment:
  470. generator.emit<Bytecode::Op::UnsignedRightShift>(lhs_reg);
  471. break;
  472. case AssignmentOp::AndAssignment:
  473. case AssignmentOp::OrAssignment:
  474. case AssignmentOp::NullishAssignment:
  475. break; // These are handled above.
  476. default:
  477. return Bytecode::CodeGenerationError {
  478. this,
  479. "Unimplemented operation"sv,
  480. };
  481. }
  482. TRY(generator.emit_store_to_reference(lhs));
  483. if (end_block_ptr) {
  484. generator.emit<Bytecode::Op::Jump>().set_targets(
  485. Bytecode::Label { *end_block_ptr },
  486. {});
  487. generator.switch_to_basic_block(*end_block_ptr);
  488. }
  489. return {};
  490. }
  491. // 14.13.3 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-labelled-statements-runtime-semantics-evaluation
  492. // LabelledStatement : LabelIdentifier : LabelledItem
  493. Bytecode::CodeGenerationErrorOr<void> LabelledStatement::generate_bytecode(Bytecode::Generator& generator) const
  494. {
  495. // Return ? LabelledEvaluation of this LabelledStatement with argument « ».
  496. return generate_labelled_evaluation(generator, {});
  497. }
  498. // 14.13.4 Runtime Semantics: LabelledEvaluation, https://tc39.es/ecma262/#sec-runtime-semantics-labelledevaluation
  499. // LabelledStatement : LabelIdentifier : LabelledItem
  500. Bytecode::CodeGenerationErrorOr<void> LabelledStatement::generate_labelled_evaluation(Bytecode::Generator& generator, Vector<DeprecatedFlyString> const& label_set) const
  501. {
  502. // Convert the m_labelled_item NNRP to a reference early so we don't have to do it every single time we want to use it.
  503. auto const& labelled_item = *m_labelled_item;
  504. // 1. Let label be the StringValue of LabelIdentifier.
  505. // NOTE: Not necessary, this is m_label.
  506. // 2. Let newLabelSet be the list-concatenation of labelSet and « label ».
  507. // FIXME: Avoid copy here.
  508. auto new_label_set = label_set;
  509. new_label_set.append(m_label);
  510. // 3. Let stmtResult be LabelledEvaluation of LabelledItem with argument newLabelSet.
  511. // NOTE: stmtResult will be in the accumulator after running the generated bytecode.
  512. if (is<IterationStatement>(labelled_item)) {
  513. auto const& iteration_statement = static_cast<IterationStatement const&>(labelled_item);
  514. TRY(iteration_statement.generate_labelled_evaluation(generator, new_label_set));
  515. } else if (is<SwitchStatement>(labelled_item)) {
  516. auto const& switch_statement = static_cast<SwitchStatement const&>(labelled_item);
  517. TRY(switch_statement.generate_labelled_evaluation(generator, new_label_set));
  518. } else if (is<LabelledStatement>(labelled_item)) {
  519. auto const& labelled_statement = static_cast<LabelledStatement const&>(labelled_item);
  520. TRY(labelled_statement.generate_labelled_evaluation(generator, new_label_set));
  521. } else {
  522. auto& labelled_break_block = generator.make_block();
  523. // NOTE: We do not need a continuable scope as `continue;` is not allowed outside of iteration statements, throwing a SyntaxError in the parser.
  524. generator.begin_breakable_scope(Bytecode::Label { labelled_break_block }, new_label_set);
  525. TRY(labelled_item.generate_bytecode(generator));
  526. generator.end_breakable_scope();
  527. if (!generator.is_current_block_terminated()) {
  528. generator.emit<Bytecode::Op::Jump>().set_targets(
  529. Bytecode::Label { labelled_break_block },
  530. {});
  531. }
  532. generator.switch_to_basic_block(labelled_break_block);
  533. }
  534. // 4. If stmtResult.[[Type]] is break and SameValue(stmtResult.[[Target]], label) is true, then
  535. // a. Set stmtResult to NormalCompletion(stmtResult.[[Value]]).
  536. // NOTE: These steps are performed by making labelled break jump straight to the appropriate break block, which preserves the statement result's value in the accumulator.
  537. // 5. Return Completion(stmtResult).
  538. // NOTE: This is in the accumulator.
  539. return {};
  540. }
  541. Bytecode::CodeGenerationErrorOr<void> IterationStatement::generate_labelled_evaluation(Bytecode::Generator&, Vector<DeprecatedFlyString> const&) const
  542. {
  543. return Bytecode::CodeGenerationError {
  544. this,
  545. "Missing generate_labelled_evaluation()"sv,
  546. };
  547. }
  548. Bytecode::CodeGenerationErrorOr<void> WhileStatement::generate_bytecode(Bytecode::Generator& generator) const
  549. {
  550. return generate_labelled_evaluation(generator, {});
  551. }
  552. Bytecode::CodeGenerationErrorOr<void> WhileStatement::generate_labelled_evaluation(Bytecode::Generator& generator, Vector<DeprecatedFlyString> const& label_set) const
  553. {
  554. // test
  555. // jump if_false (true) end (false) body
  556. // body
  557. // jump always (true) test
  558. // end
  559. auto& test_block = generator.make_block();
  560. auto& body_block = generator.make_block();
  561. auto& load_result_and_jump_to_end_block = generator.make_block();
  562. auto& end_block = generator.make_block();
  563. // Init result register
  564. generator.emit<Bytecode::Op::LoadImmediate>(js_undefined());
  565. auto result_reg = generator.allocate_register();
  566. // jump to the test block
  567. generator.emit<Bytecode::Op::Jump>().set_targets(
  568. Bytecode::Label { test_block },
  569. {});
  570. generator.switch_to_basic_block(test_block);
  571. generator.emit<Bytecode::Op::Store>(result_reg);
  572. TRY(m_test->generate_bytecode(generator));
  573. generator.emit<Bytecode::Op::JumpConditional>().set_targets(
  574. Bytecode::Label { body_block },
  575. Bytecode::Label { load_result_and_jump_to_end_block });
  576. generator.switch_to_basic_block(body_block);
  577. generator.begin_continuable_scope(Bytecode::Label { test_block }, label_set);
  578. generator.begin_breakable_scope(Bytecode::Label { end_block }, label_set);
  579. TRY(m_body->generate_bytecode(generator));
  580. generator.end_breakable_scope();
  581. generator.end_continuable_scope();
  582. if (!generator.is_current_block_terminated()) {
  583. generator.emit<Bytecode::Op::Jump>().set_targets(
  584. Bytecode::Label { test_block },
  585. {});
  586. }
  587. generator.switch_to_basic_block(load_result_and_jump_to_end_block);
  588. generator.emit<Bytecode::Op::Load>(result_reg);
  589. generator.emit<Bytecode::Op::Jump>(Bytecode::Label { end_block });
  590. generator.switch_to_basic_block(end_block);
  591. return {};
  592. }
  593. Bytecode::CodeGenerationErrorOr<void> DoWhileStatement::generate_bytecode(Bytecode::Generator& generator) const
  594. {
  595. return generate_labelled_evaluation(generator, {});
  596. }
  597. Bytecode::CodeGenerationErrorOr<void> DoWhileStatement::generate_labelled_evaluation(Bytecode::Generator& generator, Vector<DeprecatedFlyString> const& label_set) const
  598. {
  599. // jump always (true) body
  600. // test
  601. // jump if_false (true) end (false) body
  602. // body
  603. // jump always (true) test
  604. // end
  605. auto& test_block = generator.make_block();
  606. auto& body_block = generator.make_block();
  607. auto& load_result_and_jump_to_end_block = generator.make_block();
  608. auto& end_block = generator.make_block();
  609. // Init result register
  610. generator.emit<Bytecode::Op::LoadImmediate>(js_undefined());
  611. auto result_reg = generator.allocate_register();
  612. generator.emit<Bytecode::Op::Store>(result_reg);
  613. // jump to the body block
  614. generator.emit<Bytecode::Op::Jump>().set_targets(
  615. Bytecode::Label { body_block },
  616. {});
  617. generator.switch_to_basic_block(test_block);
  618. generator.emit<Bytecode::Op::Store>(result_reg);
  619. TRY(m_test->generate_bytecode(generator));
  620. generator.emit<Bytecode::Op::JumpConditional>().set_targets(
  621. Bytecode::Label { body_block },
  622. Bytecode::Label { load_result_and_jump_to_end_block });
  623. generator.switch_to_basic_block(body_block);
  624. generator.begin_continuable_scope(Bytecode::Label { test_block }, label_set);
  625. generator.begin_breakable_scope(Bytecode::Label { end_block }, label_set);
  626. TRY(m_body->generate_bytecode(generator));
  627. generator.end_breakable_scope();
  628. generator.end_continuable_scope();
  629. if (!generator.is_current_block_terminated()) {
  630. generator.emit<Bytecode::Op::Jump>().set_targets(
  631. Bytecode::Label { test_block },
  632. {});
  633. }
  634. generator.switch_to_basic_block(load_result_and_jump_to_end_block);
  635. generator.emit<Bytecode::Op::Load>(result_reg);
  636. generator.emit<Bytecode::Op::Jump>(Bytecode::Label { end_block });
  637. generator.switch_to_basic_block(end_block);
  638. return {};
  639. }
  640. Bytecode::CodeGenerationErrorOr<void> ForStatement::generate_bytecode(Bytecode::Generator& generator) const
  641. {
  642. return generate_labelled_evaluation(generator, {});
  643. }
  644. Bytecode::CodeGenerationErrorOr<void> ForStatement::generate_labelled_evaluation(Bytecode::Generator& generator, Vector<DeprecatedFlyString> const& label_set) const
  645. {
  646. // init
  647. // jump always (true) test
  648. // test
  649. // jump if_true (true) body (false) end
  650. // body
  651. // jump always (true) update
  652. // update
  653. // jump always (true) test
  654. // end
  655. // If 'test' is missing, fuse the 'test' and 'body' basic blocks
  656. // If 'update' is missing, fuse the 'body' and 'update' basic blocks
  657. Bytecode::BasicBlock* test_block_ptr { nullptr };
  658. Bytecode::BasicBlock* body_block_ptr { nullptr };
  659. Bytecode::BasicBlock* update_block_ptr { nullptr };
  660. Bytecode::BasicBlock* load_result_and_jump_to_end_block_ptr { nullptr };
  661. auto& end_block = generator.make_block();
  662. bool has_lexical_environment = false;
  663. if (m_init) {
  664. if (m_init->is_variable_declaration()) {
  665. auto& variable_declaration = verify_cast<VariableDeclaration>(*m_init);
  666. if (variable_declaration.is_lexical_declaration()) {
  667. has_lexical_environment = true;
  668. // FIXME: Is Block correct?
  669. generator.begin_variable_scope();
  670. bool is_const = variable_declaration.is_constant_declaration();
  671. // NOTE: Nothing in the callback throws an exception.
  672. MUST(variable_declaration.for_each_bound_name([&](auto const& name) {
  673. auto index = generator.intern_identifier(name);
  674. generator.emit<Bytecode::Op::CreateVariable>(index, Bytecode::Op::EnvironmentMode::Lexical, is_const);
  675. }));
  676. }
  677. }
  678. TRY(m_init->generate_bytecode(generator));
  679. }
  680. body_block_ptr = &generator.make_block();
  681. if (m_test)
  682. test_block_ptr = &generator.make_block();
  683. else
  684. test_block_ptr = body_block_ptr;
  685. if (m_update)
  686. update_block_ptr = &generator.make_block();
  687. else
  688. update_block_ptr = body_block_ptr;
  689. generator.emit<Bytecode::Op::LoadImmediate>(js_undefined());
  690. auto result_reg = generator.allocate_register();
  691. if (m_test && m_update)
  692. generator.emit<Bytecode::Op::Store>(result_reg);
  693. generator.emit<Bytecode::Op::Jump>().set_targets(
  694. Bytecode::Label { *test_block_ptr },
  695. {});
  696. if (m_test) {
  697. load_result_and_jump_to_end_block_ptr = &generator.make_block();
  698. generator.switch_to_basic_block(*test_block_ptr);
  699. if (!m_update)
  700. generator.emit<Bytecode::Op::Store>(result_reg);
  701. TRY(m_test->generate_bytecode(generator));
  702. generator.emit<Bytecode::Op::JumpConditional>().set_targets(
  703. Bytecode::Label { *body_block_ptr },
  704. Bytecode::Label { *load_result_and_jump_to_end_block_ptr });
  705. }
  706. if (m_update) {
  707. generator.switch_to_basic_block(*update_block_ptr);
  708. if (m_test)
  709. generator.emit<Bytecode::Op::Store>(result_reg);
  710. TRY(m_update->generate_bytecode(generator));
  711. generator.emit<Bytecode::Op::Jump>().set_targets(
  712. Bytecode::Label { *test_block_ptr },
  713. {});
  714. }
  715. generator.switch_to_basic_block(*body_block_ptr);
  716. generator.begin_continuable_scope(Bytecode::Label { m_update ? *update_block_ptr : *test_block_ptr }, label_set);
  717. generator.begin_breakable_scope(Bytecode::Label { end_block }, label_set);
  718. TRY(m_body->generate_bytecode(generator));
  719. generator.end_breakable_scope();
  720. generator.end_continuable_scope();
  721. if (!generator.is_current_block_terminated()) {
  722. if (m_update) {
  723. generator.emit<Bytecode::Op::Jump>().set_targets(
  724. Bytecode::Label { *update_block_ptr },
  725. {});
  726. } else {
  727. generator.emit<Bytecode::Op::Jump>().set_targets(
  728. Bytecode::Label { *test_block_ptr },
  729. {});
  730. }
  731. }
  732. if (load_result_and_jump_to_end_block_ptr) {
  733. generator.switch_to_basic_block(*load_result_and_jump_to_end_block_ptr);
  734. generator.emit<Bytecode::Op::Load>(result_reg);
  735. generator.emit<Bytecode::Op::Jump>(Bytecode::Label { end_block });
  736. }
  737. generator.switch_to_basic_block(end_block);
  738. if (has_lexical_environment)
  739. generator.end_variable_scope();
  740. return {};
  741. }
  742. Bytecode::CodeGenerationErrorOr<void> ObjectExpression::generate_bytecode(Bytecode::Generator& generator) const
  743. {
  744. generator.emit<Bytecode::Op::NewObject>();
  745. if (m_properties.is_empty())
  746. return {};
  747. auto object_reg = generator.allocate_register();
  748. generator.emit<Bytecode::Op::Store>(object_reg);
  749. generator.push_home_object(object_reg);
  750. for (auto& property : m_properties) {
  751. Bytecode::Op::PropertyKind property_kind;
  752. switch (property->type()) {
  753. case ObjectProperty::Type::KeyValue:
  754. property_kind = Bytecode::Op::PropertyKind::KeyValue;
  755. break;
  756. case ObjectProperty::Type::Getter:
  757. property_kind = Bytecode::Op::PropertyKind::Getter;
  758. break;
  759. case ObjectProperty::Type::Setter:
  760. property_kind = Bytecode::Op::PropertyKind::Setter;
  761. break;
  762. case ObjectProperty::Type::Spread:
  763. property_kind = Bytecode::Op::PropertyKind::Spread;
  764. break;
  765. case ObjectProperty::Type::ProtoSetter:
  766. property_kind = Bytecode::Op::PropertyKind::ProtoSetter;
  767. break;
  768. }
  769. if (is<StringLiteral>(property->key())) {
  770. auto& string_literal = static_cast<StringLiteral const&>(property->key());
  771. Bytecode::IdentifierTableIndex key_name = generator.intern_identifier(string_literal.value());
  772. if (property_kind == Bytecode::Op::PropertyKind::ProtoSetter) {
  773. TRY(property->value().generate_bytecode(generator));
  774. } else if (property_kind != Bytecode::Op::PropertyKind::Spread) {
  775. DeprecatedFlyString name = string_literal.value();
  776. TRY(generator.emit_named_evaluation_if_anonymous_function(property->value(), name));
  777. }
  778. generator.emit<Bytecode::Op::PutById>(object_reg, key_name, property_kind);
  779. } else {
  780. TRY(property->key().generate_bytecode(generator));
  781. auto property_reg = generator.allocate_register();
  782. generator.emit<Bytecode::Op::Store>(property_reg);
  783. if (property_kind != Bytecode::Op::PropertyKind::Spread)
  784. TRY(property->value().generate_bytecode(generator));
  785. generator.emit<Bytecode::Op::PutByValue>(object_reg, property_reg, property_kind);
  786. }
  787. }
  788. generator.emit<Bytecode::Op::Load>(object_reg);
  789. generator.pop_home_object();
  790. return {};
  791. }
  792. Bytecode::CodeGenerationErrorOr<void> ArrayExpression::generate_bytecode(Bytecode::Generator& generator) const
  793. {
  794. if (m_elements.is_empty()) {
  795. generator.emit<Bytecode::Op::NewArray>();
  796. return {};
  797. }
  798. auto first_spread = find_if(m_elements.begin(), m_elements.end(), [](auto el) { return el && is<SpreadExpression>(*el); });
  799. Bytecode::Register args_start_reg { 0 };
  800. for (auto it = m_elements.begin(); it != first_spread; ++it) {
  801. auto reg = generator.allocate_register();
  802. if (args_start_reg.index() == 0)
  803. args_start_reg = reg;
  804. }
  805. u32 i = 0;
  806. for (auto it = m_elements.begin(); it != first_spread; ++it, ++i) {
  807. Bytecode::Register reg { args_start_reg.index() + i };
  808. if (!*it)
  809. generator.emit<Bytecode::Op::LoadImmediate>(Value {});
  810. else {
  811. TRY((*it)->generate_bytecode(generator));
  812. }
  813. generator.emit<Bytecode::Op::Store>(reg);
  814. }
  815. if (first_spread.index() != 0)
  816. generator.emit_with_extra_register_slots<Bytecode::Op::NewArray>(2u, AK::Array { args_start_reg, Bytecode::Register { args_start_reg.index() + static_cast<u32>(first_spread.index() - 1) } });
  817. else
  818. generator.emit<Bytecode::Op::NewArray>();
  819. if (first_spread != m_elements.end()) {
  820. auto array_reg = generator.allocate_register();
  821. generator.emit<Bytecode::Op::Store>(array_reg);
  822. for (auto it = first_spread; it != m_elements.end(); ++it) {
  823. if (!*it) {
  824. generator.emit<Bytecode::Op::LoadImmediate>(Value {});
  825. generator.emit<Bytecode::Op::Append>(array_reg, false);
  826. } else {
  827. TRY((*it)->generate_bytecode(generator));
  828. generator.emit<Bytecode::Op::Append>(array_reg, *it && is<SpreadExpression>(**it));
  829. }
  830. }
  831. generator.emit<Bytecode::Op::Load>(array_reg);
  832. }
  833. return {};
  834. }
  835. Bytecode::CodeGenerationErrorOr<void> MemberExpression::generate_bytecode(Bytecode::Generator& generator) const
  836. {
  837. return generator.emit_load_from_reference(*this);
  838. }
  839. Bytecode::CodeGenerationErrorOr<void> FunctionDeclaration::generate_bytecode(Bytecode::Generator& generator) const
  840. {
  841. if (m_is_hoisted) {
  842. auto index = generator.intern_identifier(name());
  843. generator.emit<Bytecode::Op::GetVariable>(index);
  844. generator.emit<Bytecode::Op::SetVariable>(index, Bytecode::Op::SetVariable::InitializationMode::Set, Bytecode::Op::EnvironmentMode::Var);
  845. }
  846. return {};
  847. }
  848. Bytecode::CodeGenerationErrorOr<void> FunctionExpression::generate_bytecode_with_lhs_name(Bytecode::Generator& generator, Optional<DeprecatedFlyString const&> lhs_name) const
  849. {
  850. bool has_name = !name().is_empty();
  851. Optional<Bytecode::IdentifierTableIndex> name_identifier;
  852. if (has_name) {
  853. generator.begin_variable_scope();
  854. name_identifier = generator.intern_identifier(name());
  855. generator.emit<Bytecode::Op::CreateVariable>(*name_identifier, Bytecode::Op::EnvironmentMode::Lexical, true);
  856. }
  857. generator.emit_new_function(*this, lhs_name);
  858. if (has_name) {
  859. generator.emit<Bytecode::Op::SetVariable>(*name_identifier, Bytecode::Op::SetVariable::InitializationMode::Initialize, Bytecode::Op::EnvironmentMode::Lexical);
  860. generator.end_variable_scope();
  861. }
  862. return {};
  863. }
  864. Bytecode::CodeGenerationErrorOr<void> FunctionExpression::generate_bytecode(Bytecode::Generator& generator) const
  865. {
  866. return generate_bytecode_with_lhs_name(generator, {});
  867. }
  868. static Bytecode::CodeGenerationErrorOr<void> generate_object_binding_pattern_bytecode(Bytecode::Generator& generator, BindingPattern const& pattern, Bytecode::Op::SetVariable::InitializationMode initialization_mode, Bytecode::Register const& value_reg, bool create_variables)
  869. {
  870. generator.emit<Bytecode::Op::ThrowIfNullish>();
  871. Vector<Bytecode::Register> excluded_property_names;
  872. auto has_rest = false;
  873. if (pattern.entries.size() > 0)
  874. has_rest = pattern.entries[pattern.entries.size() - 1].is_rest;
  875. for (auto& [name, alias, initializer, is_rest] : pattern.entries) {
  876. if (is_rest) {
  877. VERIFY(name.has<NonnullRefPtr<Identifier const>>());
  878. VERIFY(alias.has<Empty>());
  879. VERIFY(!initializer);
  880. auto identifier = name.get<NonnullRefPtr<Identifier const>>()->string();
  881. auto interned_identifier = generator.intern_identifier(identifier);
  882. generator.emit_with_extra_register_slots<Bytecode::Op::CopyObjectExcludingProperties>(excluded_property_names.size(), value_reg, excluded_property_names);
  883. if (create_variables)
  884. generator.emit<Bytecode::Op::CreateVariable>(interned_identifier, Bytecode::Op::EnvironmentMode::Lexical, false);
  885. generator.emit<Bytecode::Op::SetVariable>(interned_identifier, initialization_mode);
  886. return {};
  887. }
  888. Bytecode::StringTableIndex name_index;
  889. if (name.has<NonnullRefPtr<Identifier const>>()) {
  890. auto identifier = name.get<NonnullRefPtr<Identifier const>>()->string();
  891. name_index = generator.intern_string(identifier);
  892. if (has_rest) {
  893. auto excluded_name_reg = generator.allocate_register();
  894. excluded_property_names.append(excluded_name_reg);
  895. generator.emit<Bytecode::Op::NewString>(name_index);
  896. generator.emit<Bytecode::Op::Store>(excluded_name_reg);
  897. }
  898. generator.emit<Bytecode::Op::Load>(value_reg);
  899. generator.emit<Bytecode::Op::GetById>(generator.intern_identifier(identifier));
  900. } else {
  901. auto expression = name.get<NonnullRefPtr<Expression const>>();
  902. TRY(expression->generate_bytecode(generator));
  903. if (has_rest) {
  904. auto excluded_name_reg = generator.allocate_register();
  905. excluded_property_names.append(excluded_name_reg);
  906. generator.emit<Bytecode::Op::Store>(excluded_name_reg);
  907. }
  908. generator.emit<Bytecode::Op::GetByValue>(value_reg);
  909. }
  910. if (initializer) {
  911. auto& if_undefined_block = generator.make_block();
  912. auto& if_not_undefined_block = generator.make_block();
  913. generator.emit<Bytecode::Op::JumpUndefined>().set_targets(
  914. Bytecode::Label { if_undefined_block },
  915. Bytecode::Label { if_not_undefined_block });
  916. generator.switch_to_basic_block(if_undefined_block);
  917. if (auto const* alias_identifier = alias.get_pointer<NonnullRefPtr<Identifier const>>()) {
  918. TRY(generator.emit_named_evaluation_if_anonymous_function(*initializer, (*alias_identifier)->string()));
  919. } else if (auto const* lhs = name.get_pointer<NonnullRefPtr<Identifier const>>()) {
  920. TRY(generator.emit_named_evaluation_if_anonymous_function(*initializer, (*lhs)->string()));
  921. } else {
  922. TRY(initializer->generate_bytecode(generator));
  923. }
  924. generator.emit<Bytecode::Op::Jump>().set_targets(
  925. Bytecode::Label { if_not_undefined_block },
  926. {});
  927. generator.switch_to_basic_block(if_not_undefined_block);
  928. }
  929. if (alias.has<NonnullRefPtr<BindingPattern const>>()) {
  930. auto& binding_pattern = *alias.get<NonnullRefPtr<BindingPattern const>>();
  931. auto nested_value_reg = generator.allocate_register();
  932. generator.emit<Bytecode::Op::Store>(nested_value_reg);
  933. TRY(generate_binding_pattern_bytecode(generator, binding_pattern, initialization_mode, nested_value_reg, create_variables));
  934. } else if (alias.has<Empty>()) {
  935. if (name.has<NonnullRefPtr<Expression const>>()) {
  936. // This needs some sort of SetVariableByValue opcode, as it's a runtime binding
  937. return Bytecode::CodeGenerationError {
  938. name.get<NonnullRefPtr<Expression const>>().ptr(),
  939. "Unimplemented name/alias pair: Empty/Expression"sv,
  940. };
  941. }
  942. auto& identifier = name.get<NonnullRefPtr<Identifier const>>()->string();
  943. auto identifier_ref = generator.intern_identifier(identifier);
  944. if (create_variables)
  945. generator.emit<Bytecode::Op::CreateVariable>(identifier_ref, Bytecode::Op::EnvironmentMode::Lexical, false);
  946. generator.emit<Bytecode::Op::SetVariable>(identifier_ref, initialization_mode);
  947. } else if (alias.has<NonnullRefPtr<MemberExpression const>>()) {
  948. TRY(generator.emit_store_to_reference(alias.get<NonnullRefPtr<MemberExpression const>>()));
  949. } else {
  950. auto& identifier = alias.get<NonnullRefPtr<Identifier const>>()->string();
  951. auto identifier_ref = generator.intern_identifier(identifier);
  952. if (create_variables)
  953. generator.emit<Bytecode::Op::CreateVariable>(identifier_ref, Bytecode::Op::EnvironmentMode::Lexical, false);
  954. generator.emit<Bytecode::Op::SetVariable>(identifier_ref, initialization_mode);
  955. }
  956. }
  957. return {};
  958. }
  959. static Bytecode::CodeGenerationErrorOr<void> generate_array_binding_pattern_bytecode(Bytecode::Generator& generator, BindingPattern const& pattern, Bytecode::Op::SetVariable::InitializationMode initialization_mode, Bytecode::Register const& value_reg, bool create_variables)
  960. {
  961. /*
  962. * Consider the following destructuring assignment:
  963. *
  964. * let [a, b, c, d, e] = o;
  965. *
  966. * It would be fairly trivial to just loop through this iterator, getting the value
  967. * at each step and assigning them to the binding sequentially. However, this is not
  968. * correct: once an iterator is exhausted, it must not be called again. This complicates
  969. * the bytecode. In order to accomplish this, we do the following:
  970. *
  971. * - Reserve a special boolean register which holds 'true' if the iterator is exhausted,
  972. * and false otherwise
  973. * - When we are retrieving the value which should be bound, we first check this register.
  974. * If it is 'true', we load undefined into the accumulator. Otherwise, we grab the next
  975. * value from the iterator and store it into the accumulator.
  976. *
  977. * Note that the is_exhausted register does not need to be loaded with false because the
  978. * first IteratorNext bytecode is _not_ proceeded by an exhausted check, as it is
  979. * unnecessary.
  980. */
  981. auto is_iterator_exhausted_register = generator.allocate_register();
  982. generator.emit<Bytecode::Op::LoadImmediate>(Value(false));
  983. generator.emit<Bytecode::Op::Store>(is_iterator_exhausted_register);
  984. auto iterator_reg = generator.allocate_register();
  985. generator.emit<Bytecode::Op::Load>(value_reg);
  986. generator.emit<Bytecode::Op::GetIterator>();
  987. generator.emit<Bytecode::Op::Store>(iterator_reg);
  988. bool first = true;
  989. auto temp_iterator_result_reg = generator.allocate_register();
  990. auto assign_accumulator_to_alias = [&](auto& alias) {
  991. return alias.visit(
  992. [&](Empty) -> Bytecode::CodeGenerationErrorOr<void> {
  993. // This element is an elision
  994. return {};
  995. },
  996. [&](NonnullRefPtr<Identifier const> const& identifier) -> Bytecode::CodeGenerationErrorOr<void> {
  997. auto interned_index = generator.intern_identifier(identifier->string());
  998. if (create_variables)
  999. generator.emit<Bytecode::Op::CreateVariable>(interned_index, Bytecode::Op::EnvironmentMode::Lexical, false);
  1000. generator.emit<Bytecode::Op::SetVariable>(interned_index, initialization_mode);
  1001. return {};
  1002. },
  1003. [&](NonnullRefPtr<BindingPattern const> const& pattern) -> Bytecode::CodeGenerationErrorOr<void> {
  1004. // Store the accumulator value in a permanent register
  1005. auto target_reg = generator.allocate_register();
  1006. generator.emit<Bytecode::Op::Store>(target_reg);
  1007. return generate_binding_pattern_bytecode(generator, pattern, initialization_mode, target_reg, create_variables);
  1008. },
  1009. [&](NonnullRefPtr<MemberExpression const> const& expr) -> Bytecode::CodeGenerationErrorOr<void> {
  1010. return generator.emit_store_to_reference(*expr);
  1011. });
  1012. };
  1013. for (auto& [name, alias, initializer, is_rest] : pattern.entries) {
  1014. VERIFY(name.has<Empty>());
  1015. if (is_rest) {
  1016. VERIFY(!initializer);
  1017. if (first) {
  1018. // The iterator has not been called, and is thus known to be not exhausted
  1019. generator.emit<Bytecode::Op::Load>(iterator_reg);
  1020. generator.emit<Bytecode::Op::IteratorToArray>();
  1021. } else {
  1022. auto& if_exhausted_block = generator.make_block();
  1023. auto& if_not_exhausted_block = generator.make_block();
  1024. auto& continuation_block = generator.make_block();
  1025. generator.emit<Bytecode::Op::Load>(is_iterator_exhausted_register);
  1026. generator.emit<Bytecode::Op::JumpConditional>().set_targets(
  1027. Bytecode::Label { if_exhausted_block },
  1028. Bytecode::Label { if_not_exhausted_block });
  1029. generator.switch_to_basic_block(if_exhausted_block);
  1030. generator.emit<Bytecode::Op::NewArray>();
  1031. generator.emit<Bytecode::Op::Jump>().set_targets(
  1032. Bytecode::Label { continuation_block },
  1033. {});
  1034. generator.switch_to_basic_block(if_not_exhausted_block);
  1035. generator.emit<Bytecode::Op::Load>(iterator_reg);
  1036. generator.emit<Bytecode::Op::IteratorToArray>();
  1037. generator.emit<Bytecode::Op::Jump>().set_targets(
  1038. Bytecode::Label { continuation_block },
  1039. {});
  1040. generator.switch_to_basic_block(continuation_block);
  1041. }
  1042. return assign_accumulator_to_alias(alias);
  1043. }
  1044. // In the first iteration of the loop, a few things are true which can save
  1045. // us some bytecode:
  1046. // - the iterator result is still in the accumulator, so we can avoid a load
  1047. // - the iterator is not yet exhausted, which can save us a jump and some
  1048. // creation
  1049. auto& iterator_is_exhausted_block = generator.make_block();
  1050. if (!first) {
  1051. auto& iterator_is_not_exhausted_block = generator.make_block();
  1052. generator.emit<Bytecode::Op::Load>(is_iterator_exhausted_register);
  1053. generator.emit<Bytecode::Op::JumpConditional>().set_targets(
  1054. Bytecode::Label { iterator_is_exhausted_block },
  1055. Bytecode::Label { iterator_is_not_exhausted_block });
  1056. generator.switch_to_basic_block(iterator_is_not_exhausted_block);
  1057. generator.emit<Bytecode::Op::Load>(iterator_reg);
  1058. }
  1059. generator.emit<Bytecode::Op::IteratorNext>();
  1060. generator.emit<Bytecode::Op::Store>(temp_iterator_result_reg);
  1061. generator.emit<Bytecode::Op::IteratorResultDone>();
  1062. generator.emit<Bytecode::Op::Store>(is_iterator_exhausted_register);
  1063. // We still have to check for exhaustion here. If the iterator is exhausted,
  1064. // we need to bail before trying to get the value
  1065. auto& no_bail_block = generator.make_block();
  1066. generator.emit<Bytecode::Op::JumpConditional>().set_targets(
  1067. Bytecode::Label { iterator_is_exhausted_block },
  1068. Bytecode::Label { no_bail_block });
  1069. generator.switch_to_basic_block(no_bail_block);
  1070. // Get the next value in the iterator
  1071. generator.emit<Bytecode::Op::Load>(temp_iterator_result_reg);
  1072. generator.emit<Bytecode::Op::IteratorResultValue>();
  1073. auto& create_binding_block = generator.make_block();
  1074. generator.emit<Bytecode::Op::Jump>().set_targets(
  1075. Bytecode::Label { create_binding_block },
  1076. {});
  1077. // The iterator is exhausted, so we just load undefined and continue binding
  1078. generator.switch_to_basic_block(iterator_is_exhausted_block);
  1079. generator.emit<Bytecode::Op::LoadImmediate>(js_undefined());
  1080. generator.emit<Bytecode::Op::Jump>().set_targets(
  1081. Bytecode::Label { create_binding_block },
  1082. {});
  1083. // Create the actual binding. The value which this entry must bind is now in the
  1084. // accumulator. We can proceed, processing the alias as a nested destructuring
  1085. // pattern if necessary.
  1086. generator.switch_to_basic_block(create_binding_block);
  1087. if (initializer) {
  1088. auto& value_is_undefined_block = generator.make_block();
  1089. auto& value_is_not_undefined_block = generator.make_block();
  1090. generator.emit<Bytecode::Op::JumpUndefined>().set_targets(
  1091. Bytecode::Label { value_is_undefined_block },
  1092. Bytecode::Label { value_is_not_undefined_block });
  1093. generator.switch_to_basic_block(value_is_undefined_block);
  1094. if (auto const* alias_identifier = alias.get_pointer<NonnullRefPtr<Identifier const>>()) {
  1095. TRY(generator.emit_named_evaluation_if_anonymous_function(*initializer, (*alias_identifier)->string()));
  1096. } else if (auto const* name_identifier = name.get_pointer<NonnullRefPtr<Identifier const>>()) {
  1097. TRY(generator.emit_named_evaluation_if_anonymous_function(*initializer, (*name_identifier)->string()));
  1098. } else {
  1099. TRY(initializer->generate_bytecode(generator));
  1100. }
  1101. generator.emit<Bytecode::Op::Jump>(Bytecode::Label { value_is_not_undefined_block });
  1102. generator.switch_to_basic_block(value_is_not_undefined_block);
  1103. }
  1104. TRY(assign_accumulator_to_alias(alias));
  1105. first = false;
  1106. }
  1107. auto& done_block = generator.make_block();
  1108. auto& not_done_block = generator.make_block();
  1109. generator.emit<Bytecode::Op::Load>(is_iterator_exhausted_register);
  1110. generator.emit<Bytecode::Op::JumpConditional>().set_targets(
  1111. Bytecode::Label { done_block },
  1112. Bytecode::Label { not_done_block });
  1113. generator.switch_to_basic_block(not_done_block);
  1114. generator.emit<Bytecode::Op::Load>(iterator_reg);
  1115. generator.emit<Bytecode::Op::IteratorClose>(Completion::Type::Normal, Optional<Value> {});
  1116. generator.emit<Bytecode::Op::Jump>(Bytecode::Label { done_block });
  1117. generator.switch_to_basic_block(done_block);
  1118. return {};
  1119. }
  1120. static Bytecode::CodeGenerationErrorOr<void> generate_binding_pattern_bytecode(Bytecode::Generator& generator, BindingPattern const& pattern, Bytecode::Op::SetVariable::InitializationMode initialization_mode, Bytecode::Register const& value_reg, bool create_variables)
  1121. {
  1122. if (pattern.kind == BindingPattern::Kind::Object)
  1123. return generate_object_binding_pattern_bytecode(generator, pattern, initialization_mode, value_reg, create_variables);
  1124. return generate_array_binding_pattern_bytecode(generator, pattern, initialization_mode, value_reg, create_variables);
  1125. }
  1126. static Bytecode::CodeGenerationErrorOr<void> assign_accumulator_to_variable_declarator(Bytecode::Generator& generator, VariableDeclarator const& declarator, VariableDeclaration const& declaration)
  1127. {
  1128. auto initialization_mode = declaration.is_lexical_declaration() ? Bytecode::Op::SetVariable::InitializationMode::Initialize : Bytecode::Op::SetVariable::InitializationMode::Set;
  1129. return declarator.target().visit(
  1130. [&](NonnullRefPtr<Identifier const> const& id) -> Bytecode::CodeGenerationErrorOr<void> {
  1131. generator.emit<Bytecode::Op::SetVariable>(generator.intern_identifier(id->string()), initialization_mode);
  1132. return {};
  1133. },
  1134. [&](NonnullRefPtr<BindingPattern const> const& pattern) -> Bytecode::CodeGenerationErrorOr<void> {
  1135. auto value_register = generator.allocate_register();
  1136. generator.emit<Bytecode::Op::Store>(value_register);
  1137. return generate_binding_pattern_bytecode(generator, pattern, initialization_mode, value_register, false);
  1138. });
  1139. }
  1140. Bytecode::CodeGenerationErrorOr<void> VariableDeclaration::generate_bytecode(Bytecode::Generator& generator) const
  1141. {
  1142. for (auto& declarator : m_declarations) {
  1143. if (declarator->init()) {
  1144. if (auto const* lhs = declarator->target().get_pointer<NonnullRefPtr<Identifier const>>()) {
  1145. TRY(generator.emit_named_evaluation_if_anonymous_function(*declarator->init(), (*lhs)->string()));
  1146. } else {
  1147. TRY(declarator->init()->generate_bytecode(generator));
  1148. }
  1149. TRY(assign_accumulator_to_variable_declarator(generator, declarator, *this));
  1150. } else if (m_declaration_kind != DeclarationKind::Var) {
  1151. generator.emit<Bytecode::Op::LoadImmediate>(js_undefined());
  1152. TRY(assign_accumulator_to_variable_declarator(generator, declarator, *this));
  1153. }
  1154. }
  1155. return {};
  1156. }
  1157. static Bytecode::CodeGenerationErrorOr<void> get_base_and_value_from_member_expression(Bytecode::Generator& generator, MemberExpression const& member_expression, Bytecode::Register this_reg)
  1158. {
  1159. // https://tc39.es/ecma262/#sec-super-keyword-runtime-semantics-evaluation
  1160. if (is<SuperExpression>(member_expression.object())) {
  1161. // 1. Let env be GetThisEnvironment().
  1162. // 2. Let actualThis be ? env.GetThisBinding().
  1163. generator.emit<Bytecode::Op::ResolveThisBinding>();
  1164. generator.emit<Bytecode::Op::Store>(this_reg);
  1165. Optional<Bytecode::Register> computed_property_value_register;
  1166. if (member_expression.is_computed()) {
  1167. // SuperProperty : super [ Expression ]
  1168. // 3. Let propertyNameReference be ? Evaluation of Expression.
  1169. // 4. Let propertyNameValue be ? GetValue(propertyNameReference).
  1170. TRY(member_expression.property().generate_bytecode(generator));
  1171. computed_property_value_register = generator.allocate_register();
  1172. generator.emit<Bytecode::Op::Store>(*computed_property_value_register);
  1173. }
  1174. // 5/7. Return ? MakeSuperPropertyReference(actualThis, propertyKey, strict).
  1175. // https://tc39.es/ecma262/#sec-makesuperpropertyreference
  1176. // 1. Let env be GetThisEnvironment().
  1177. // 2. Assert: env.HasSuperBinding() is true.
  1178. // 3. Let baseValue be ? env.GetSuperBase().
  1179. generator.emit<Bytecode::Op::ResolveSuperBase>();
  1180. // 4. Return the Reference Record { [[Base]]: baseValue, [[ReferencedName]]: propertyKey, [[Strict]]: strict, [[ThisValue]]: actualThis }.
  1181. if (computed_property_value_register.has_value()) {
  1182. // 5. Let propertyKey be ? ToPropertyKey(propertyNameValue).
  1183. // FIXME: This does ToPropertyKey out of order, which is observable by Symbol.toPrimitive!
  1184. auto super_base_register = generator.allocate_register();
  1185. generator.emit<Bytecode::Op::Store>(super_base_register);
  1186. generator.emit<Bytecode::Op::Load>(*computed_property_value_register);
  1187. generator.emit<Bytecode::Op::GetByValue>(super_base_register);
  1188. } else {
  1189. // 3. Let propertyKey be StringValue of IdentifierName.
  1190. auto identifier_table_ref = generator.intern_identifier(verify_cast<Identifier>(member_expression.property()).string());
  1191. generator.emit<Bytecode::Op::GetById>(identifier_table_ref);
  1192. }
  1193. } else {
  1194. TRY(member_expression.object().generate_bytecode(generator));
  1195. generator.emit<Bytecode::Op::Store>(this_reg);
  1196. if (member_expression.is_computed()) {
  1197. TRY(member_expression.property().generate_bytecode(generator));
  1198. generator.emit<Bytecode::Op::GetByValue>(this_reg);
  1199. } else if (is<PrivateIdentifier>(member_expression.property())) {
  1200. generator.emit<Bytecode::Op::GetPrivateById>(generator.intern_identifier(verify_cast<PrivateIdentifier>(member_expression.property()).string()));
  1201. } else {
  1202. generator.emit<Bytecode::Op::GetById>(generator.intern_identifier(verify_cast<Identifier>(member_expression.property()).string()));
  1203. }
  1204. }
  1205. return {};
  1206. }
  1207. static Bytecode::CodeGenerationErrorOr<void> generate_optional_chain(Bytecode::Generator& generator, OptionalChain const& optional_chain, Bytecode::Register current_value_register, Bytecode::Register current_base_register);
  1208. Bytecode::CodeGenerationErrorOr<void> CallExpression::generate_bytecode(Bytecode::Generator& generator) const
  1209. {
  1210. auto callee_reg = generator.allocate_register();
  1211. auto this_reg = generator.allocate_register();
  1212. generator.emit<Bytecode::Op::LoadImmediate>(js_undefined());
  1213. generator.emit<Bytecode::Op::Store>(this_reg);
  1214. if (is<NewExpression>(this)) {
  1215. TRY(m_callee->generate_bytecode(generator));
  1216. generator.emit<Bytecode::Op::Store>(callee_reg);
  1217. } else if (is<MemberExpression>(*m_callee)) {
  1218. auto& member_expression = static_cast<MemberExpression const&>(*m_callee);
  1219. TRY(get_base_and_value_from_member_expression(generator, member_expression, this_reg));
  1220. generator.emit<Bytecode::Op::Store>(callee_reg);
  1221. } else if (is<OptionalChain>(*m_callee)) {
  1222. auto& optional_chain = static_cast<OptionalChain const&>(*m_callee);
  1223. TRY(generate_optional_chain(generator, optional_chain, callee_reg, this_reg));
  1224. } else {
  1225. // FIXME: this = global object in sloppy mode.
  1226. TRY(m_callee->generate_bytecode(generator));
  1227. generator.emit<Bytecode::Op::Store>(callee_reg);
  1228. }
  1229. TRY(arguments_to_array_for_call(generator, arguments()));
  1230. Bytecode::Op::Call::CallType call_type;
  1231. if (is<NewExpression>(*this)) {
  1232. call_type = Bytecode::Op::Call::CallType::Construct;
  1233. } else if (m_callee->is_identifier() && static_cast<Identifier const&>(*m_callee).string() == "eval"sv) {
  1234. call_type = Bytecode::Op::Call::CallType::DirectEval;
  1235. } else {
  1236. call_type = Bytecode::Op::Call::CallType::Call;
  1237. }
  1238. Optional<Bytecode::StringTableIndex> expression_string_index;
  1239. if (auto expression_string = this->expression_string(); expression_string.has_value())
  1240. expression_string_index = generator.intern_string(expression_string.release_value());
  1241. generator.emit<Bytecode::Op::Call>(call_type, callee_reg, this_reg, expression_string_index);
  1242. return {};
  1243. }
  1244. Bytecode::CodeGenerationErrorOr<void> ReturnStatement::generate_bytecode(Bytecode::Generator& generator) const
  1245. {
  1246. if (m_argument)
  1247. TRY(m_argument->generate_bytecode(generator));
  1248. else
  1249. generator.emit<Bytecode::Op::LoadImmediate>(js_undefined());
  1250. if (generator.is_in_generator_or_async_function()) {
  1251. generator.perform_needed_unwinds<Bytecode::Op::Yield>();
  1252. generator.emit<Bytecode::Op::Yield>(nullptr);
  1253. } else {
  1254. generator.perform_needed_unwinds<Bytecode::Op::Return>();
  1255. generator.emit<Bytecode::Op::Return>();
  1256. }
  1257. return {};
  1258. }
  1259. Bytecode::CodeGenerationErrorOr<void> YieldExpression::generate_bytecode(Bytecode::Generator& generator) const
  1260. {
  1261. VERIFY(generator.is_in_generator_function());
  1262. auto received_completion_register = generator.allocate_register();
  1263. auto received_completion_type_register = generator.allocate_register();
  1264. auto received_completion_value_register = generator.allocate_register();
  1265. auto type_identifier = generator.intern_identifier("type");
  1266. auto value_identifier = generator.intern_identifier("value");
  1267. auto get_received_completion_type_and_value = [&]() {
  1268. // The accumulator is set to an object, for example: { "type": 1 (normal), value: 1337 }
  1269. generator.emit<Bytecode::Op::Store>(received_completion_register);
  1270. generator.emit<Bytecode::Op::GetById>(type_identifier);
  1271. generator.emit<Bytecode::Op::Store>(received_completion_type_register);
  1272. generator.emit<Bytecode::Op::Load>(received_completion_register);
  1273. generator.emit<Bytecode::Op::GetById>(value_identifier);
  1274. generator.emit<Bytecode::Op::Store>(received_completion_value_register);
  1275. };
  1276. if (m_is_yield_from) {
  1277. // 15.5.5 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-generator-function-definitions-runtime-semantics-evaluation
  1278. // FIXME: 1. Let generatorKind be GetGeneratorKind().
  1279. // 2. Let exprRef be ? Evaluation of AssignmentExpression.
  1280. // 3. Let value be ? GetValue(exprRef).
  1281. VERIFY(m_argument);
  1282. TRY(m_argument->generate_bytecode(generator));
  1283. // 4. Let iteratorRecord be ? GetIterator(value, generatorKind).
  1284. // FIXME: Consider generatorKind.
  1285. auto iterator_record_register = generator.allocate_register();
  1286. generator.emit<Bytecode::Op::GetIterator>();
  1287. generator.emit<Bytecode::Op::Store>(iterator_record_register);
  1288. // 5. Let iterator be iteratorRecord.[[Iterator]].
  1289. auto iterator_register = generator.allocate_register();
  1290. auto iterator_identifier = generator.intern_identifier("iterator");
  1291. generator.emit<Bytecode::Op::GetById>(iterator_identifier);
  1292. generator.emit<Bytecode::Op::Store>(iterator_register);
  1293. // Cache iteratorRecord.[[NextMethod]] for use in step 7.a.i.
  1294. auto next_method_register = generator.allocate_register();
  1295. auto next_method_identifier = generator.intern_identifier("next");
  1296. generator.emit<Bytecode::Op::Load>(iterator_record_register);
  1297. generator.emit<Bytecode::Op::GetById>(next_method_identifier);
  1298. generator.emit<Bytecode::Op::Store>(next_method_register);
  1299. // 6. Let received be NormalCompletion(undefined).
  1300. // See get_received_completion_type_and_value above.
  1301. generator.emit<Bytecode::Op::LoadImmediate>(Value(to_underlying(Completion::Type::Normal)));
  1302. generator.emit<Bytecode::Op::Store>(received_completion_type_register);
  1303. generator.emit<Bytecode::Op::LoadImmediate>(js_undefined());
  1304. generator.emit<Bytecode::Op::Store>(received_completion_value_register);
  1305. // 7. Repeat,
  1306. auto& loop_block = generator.make_block();
  1307. auto& continuation_block = generator.make_block();
  1308. auto& loop_end_block = generator.make_block();
  1309. generator.emit<Bytecode::Op::Jump>(Bytecode::Label { loop_block });
  1310. generator.switch_to_basic_block(loop_block);
  1311. // a. If received.[[Type]] is normal, then
  1312. auto& type_is_normal_block = generator.make_block();
  1313. auto& is_type_throw_block = generator.make_block();
  1314. generator.emit<Bytecode::Op::LoadImmediate>(Value(to_underlying(Completion::Type::Normal)));
  1315. generator.emit<Bytecode::Op::StrictlyEquals>(received_completion_type_register);
  1316. generator.emit<Bytecode::Op::JumpConditional>(
  1317. Bytecode::Label { type_is_normal_block },
  1318. Bytecode::Label { is_type_throw_block });
  1319. generator.switch_to_basic_block(type_is_normal_block);
  1320. // i. Let innerResult be ? Call(iteratorRecord.[[NextMethod]], iteratorRecord.[[Iterator]], « received.[[Value]] »).
  1321. generator.emit_with_extra_register_slots<Bytecode::Op::NewArray>(2, AK::Array { received_completion_value_register, received_completion_value_register });
  1322. generator.emit<Bytecode::Op::Call>(Bytecode::Op::Call::CallType::Call, next_method_register, iterator_register);
  1323. // FIXME: ii. If generatorKind is async, set innerResult to ? Await(innerResult).
  1324. // iii. If innerResult is not an Object, throw a TypeError exception.
  1325. generator.emit<Bytecode::Op::ThrowIfNotObject>();
  1326. auto inner_result_register = generator.allocate_register();
  1327. generator.emit<Bytecode::Op::Store>(inner_result_register);
  1328. // iv. Let done be ? IteratorComplete(innerResult).
  1329. generator.emit<Bytecode::Op::IteratorResultDone>();
  1330. // v. If done is true, then
  1331. auto& type_is_normal_done_block = generator.make_block();
  1332. auto& type_is_normal_not_done_block = generator.make_block();
  1333. generator.emit<Bytecode::Op::JumpConditional>(
  1334. Bytecode::Label { type_is_normal_done_block },
  1335. Bytecode::Label { type_is_normal_not_done_block });
  1336. generator.switch_to_basic_block(type_is_normal_done_block);
  1337. // 1. Return ? IteratorValue(innerResult).
  1338. generator.emit<Bytecode::Op::Load>(inner_result_register);
  1339. generator.emit<Bytecode::Op::IteratorResultValue>();
  1340. generator.emit<Bytecode::Op::Jump>(Bytecode::Label { loop_end_block });
  1341. generator.switch_to_basic_block(type_is_normal_not_done_block);
  1342. // FIXME: vi. If generatorKind is async, set received to Completion(AsyncGeneratorYield(? IteratorValue(innerResult))).
  1343. // vii. Else, set received to Completion(GeneratorYield(innerResult)).
  1344. // FIXME: Else,
  1345. generator.emit<Bytecode::Op::Load>(inner_result_register);
  1346. // FIXME: Yield currently only accepts a Value, not an object conforming to the IteratorResult interface, so we have to do an observable lookup of `value` here.
  1347. generator.emit<Bytecode::Op::IteratorResultValue>();
  1348. generator.emit<Bytecode::Op::Yield>(Bytecode::Label { continuation_block });
  1349. // b. Else if received.[[Type]] is throw, then
  1350. generator.switch_to_basic_block(is_type_throw_block);
  1351. auto& type_is_throw_block = generator.make_block();
  1352. auto& type_is_return_block = generator.make_block();
  1353. generator.emit<Bytecode::Op::LoadImmediate>(Value(to_underlying(Completion::Type::Throw)));
  1354. generator.emit<Bytecode::Op::StrictlyEquals>(received_completion_type_register);
  1355. generator.emit<Bytecode::Op::JumpConditional>(
  1356. Bytecode::Label { type_is_throw_block },
  1357. Bytecode::Label { type_is_return_block });
  1358. generator.switch_to_basic_block(type_is_throw_block);
  1359. // i. Let throw be ? GetMethod(iterator, "throw").
  1360. auto throw_method_register = generator.allocate_register();
  1361. auto throw_identifier = generator.intern_identifier("throw");
  1362. generator.emit<Bytecode::Op::Load>(iterator_register);
  1363. generator.emit<Bytecode::Op::GetMethod>(throw_identifier);
  1364. generator.emit<Bytecode::Op::Store>(throw_method_register);
  1365. // ii. If throw is not undefined, then
  1366. auto& throw_method_is_defined_block = generator.make_block();
  1367. auto& throw_method_is_undefined_block = generator.make_block();
  1368. generator.emit<Bytecode::Op::LoadImmediate>(js_undefined());
  1369. generator.emit<Bytecode::Op::StrictlyInequals>(throw_method_register);
  1370. generator.emit<Bytecode::Op::JumpConditional>(
  1371. Bytecode::Label { throw_method_is_defined_block },
  1372. Bytecode::Label { throw_method_is_undefined_block });
  1373. generator.switch_to_basic_block(throw_method_is_defined_block);
  1374. // 1. Let innerResult be ? Call(throw, iterator, « received.[[Value]] »).
  1375. generator.emit_with_extra_register_slots<Bytecode::Op::NewArray>(2, AK::Array { received_completion_value_register, received_completion_value_register });
  1376. generator.emit<Bytecode::Op::Call>(Bytecode::Op::Call::CallType::Call, throw_method_register, iterator_register);
  1377. // FIXME: 2. If generatorKind is async, set innerResult to ? Await(innerResult).
  1378. // 3. NOTE: Exceptions from the inner iterator throw method are propagated. Normal completions from an inner throw method are processed similarly to an inner next.
  1379. // 4. If innerResult is not an Object, throw a TypeError exception.
  1380. generator.emit<Bytecode::Op::ThrowIfNotObject>();
  1381. generator.emit<Bytecode::Op::Store>(inner_result_register);
  1382. // 5. Let done be ? IteratorComplete(innerResult).
  1383. generator.emit<Bytecode::Op::IteratorResultDone>();
  1384. // 6. If done is true, then
  1385. auto& type_is_throw_done_block = generator.make_block();
  1386. auto& type_is_throw_not_done_block = generator.make_block();
  1387. generator.emit<Bytecode::Op::JumpConditional>(
  1388. Bytecode::Label { type_is_throw_done_block },
  1389. Bytecode::Label { type_is_throw_not_done_block });
  1390. generator.switch_to_basic_block(type_is_throw_done_block);
  1391. // a. Return ? IteratorValue(innerResult).
  1392. generator.emit<Bytecode::Op::Load>(inner_result_register);
  1393. generator.emit<Bytecode::Op::IteratorResultValue>();
  1394. generator.emit<Bytecode::Op::Jump>(Bytecode::Label { loop_end_block });
  1395. generator.switch_to_basic_block(type_is_throw_not_done_block);
  1396. // FIXME: 7. If generatorKind is async, set received to Completion(AsyncGeneratorYield(? IteratorValue(innerResult))).
  1397. // 8. Else, set received to Completion(GeneratorYield(innerResult)).
  1398. // FIXME: Else,
  1399. generator.emit<Bytecode::Op::Load>(inner_result_register);
  1400. // FIXME: Yield currently only accepts a Value, not an object conforming to the IteratorResult interface, so we have to do an observable lookup of `value` here.
  1401. generator.emit<Bytecode::Op::IteratorResultValue>();
  1402. generator.emit<Bytecode::Op::Yield>(Bytecode::Label { continuation_block });
  1403. generator.switch_to_basic_block(throw_method_is_undefined_block);
  1404. // 1. NOTE: If iterator does not have a throw method, this throw is going to terminate the yield* loop. But first we need to give iterator a chance to clean up.
  1405. // 2. Let closeCompletion be Completion Record { [[Type]]: normal, [[Value]]: empty, [[Target]]: empty }.
  1406. // FIXME: 3. If generatorKind is async, perform ? AsyncIteratorClose(iteratorRecord, closeCompletion).
  1407. // 4. Else, perform ? IteratorClose(iteratorRecord, closeCompletion).
  1408. // FIXME: Else,
  1409. generator.emit<Bytecode::Op::Load>(iterator_record_register);
  1410. generator.emit<Bytecode::Op::IteratorClose>(Completion::Type::Normal, Optional<Value> {});
  1411. // 5. NOTE: The next step throws a TypeError to indicate that there was a yield* protocol violation: iterator does not have a throw method.
  1412. // 6. Throw a TypeError exception.
  1413. generator.emit<Bytecode::Op::NewTypeError>(generator.intern_string(ErrorType::YieldFromIteratorMissingThrowMethod.message()));
  1414. generator.perform_needed_unwinds<Bytecode::Op::Throw>();
  1415. generator.emit<Bytecode::Op::Throw>();
  1416. // c. Else,
  1417. // i. Assert: received.[[Type]] is return.
  1418. generator.switch_to_basic_block(type_is_return_block);
  1419. // ii. Let return be ? GetMethod(iterator, "return").
  1420. auto return_method_register = generator.allocate_register();
  1421. auto return_identifier = generator.intern_identifier("return");
  1422. generator.emit<Bytecode::Op::Load>(iterator_register);
  1423. generator.emit<Bytecode::Op::GetMethod>(return_identifier);
  1424. generator.emit<Bytecode::Op::Store>(return_method_register);
  1425. // iii. If return is undefined, then
  1426. auto& return_is_undefined_block = generator.make_block();
  1427. auto& return_is_defined_block = generator.make_block();
  1428. generator.emit<Bytecode::Op::LoadImmediate>(js_undefined());
  1429. generator.emit<Bytecode::Op::StrictlyEquals>(return_method_register);
  1430. generator.emit<Bytecode::Op::JumpConditional>(
  1431. Bytecode::Label { return_is_undefined_block },
  1432. Bytecode::Label { return_is_defined_block });
  1433. generator.switch_to_basic_block(return_is_undefined_block);
  1434. // FIXME: 1. If generatorKind is async, set received.[[Value]] to ? Await(received.[[Value]]).
  1435. // 2. Return ? received.
  1436. // NOTE: This will always be a return completion.
  1437. generator.emit<Bytecode::Op::Load>(received_completion_value_register);
  1438. generator.perform_needed_unwinds<Bytecode::Op::Yield>();
  1439. generator.emit<Bytecode::Op::Yield>(nullptr);
  1440. generator.switch_to_basic_block(return_is_defined_block);
  1441. // iv. Let innerReturnResult be ? Call(return, iterator, « received.[[Value]] »).
  1442. generator.emit_with_extra_register_slots<Bytecode::Op::NewArray>(2, AK::Array { received_completion_value_register, received_completion_value_register });
  1443. generator.emit<Bytecode::Op::Call>(Bytecode::Op::Call::CallType::Call, return_method_register, iterator_register);
  1444. // FIXME: v. If generatorKind is async, set innerReturnResult to ? Await(innerReturnResult).
  1445. // vi. If innerReturnResult is not an Object, throw a TypeError exception.
  1446. generator.emit<Bytecode::Op::ThrowIfNotObject>();
  1447. auto inner_return_result_register = generator.allocate_register();
  1448. generator.emit<Bytecode::Op::Store>(inner_return_result_register);
  1449. // vii. Let done be ? IteratorComplete(innerReturnResult).
  1450. generator.emit<Bytecode::Op::IteratorResultDone>();
  1451. // viii. If done is true, then
  1452. auto& type_is_return_done_block = generator.make_block();
  1453. auto& type_is_return_not_done_block = generator.make_block();
  1454. generator.emit<Bytecode::Op::JumpConditional>(
  1455. Bytecode::Label { type_is_return_done_block },
  1456. Bytecode::Label { type_is_return_not_done_block });
  1457. generator.switch_to_basic_block(type_is_return_done_block);
  1458. // 1. Let value be ? IteratorValue(innerReturnResult).
  1459. generator.emit<Bytecode::Op::Load>(inner_result_register);
  1460. generator.emit<Bytecode::Op::IteratorResultValue>();
  1461. // 2. Return Completion Record { [[Type]]: return, [[Value]]: value, [[Target]]: empty }.
  1462. generator.perform_needed_unwinds<Bytecode::Op::Yield>();
  1463. generator.emit<Bytecode::Op::Yield>(nullptr);
  1464. generator.switch_to_basic_block(type_is_return_not_done_block);
  1465. // FIXME: ix. If generatorKind is async, set received to Completion(AsyncGeneratorYield(? IteratorValue(innerReturnResult))).
  1466. // x. Else, set received to Completion(GeneratorYield(innerReturnResult)).
  1467. // FIXME: Else,
  1468. generator.emit<Bytecode::Op::Load>(inner_return_result_register);
  1469. // FIXME: Yield currently only accepts a Value, not an object conforming to the IteratorResult interface, so we have to do an observable lookup of `value` here.
  1470. generator.emit<Bytecode::Op::IteratorResultValue>();
  1471. generator.emit<Bytecode::Op::Yield>(Bytecode::Label { continuation_block });
  1472. generator.switch_to_basic_block(continuation_block);
  1473. get_received_completion_type_and_value();
  1474. generator.emit<Bytecode::Op::Jump>(Bytecode::Label { loop_block });
  1475. generator.switch_to_basic_block(loop_end_block);
  1476. return {};
  1477. }
  1478. if (m_argument)
  1479. TRY(m_argument->generate_bytecode(generator));
  1480. else
  1481. generator.emit<Bytecode::Op::LoadImmediate>(js_undefined());
  1482. auto& continuation_block = generator.make_block();
  1483. generator.emit<Bytecode::Op::Yield>(Bytecode::Label { continuation_block });
  1484. generator.switch_to_basic_block(continuation_block);
  1485. get_received_completion_type_and_value();
  1486. auto& normal_completion_continuation_block = generator.make_block();
  1487. auto& throw_completion_continuation_block = generator.make_block();
  1488. generator.emit<Bytecode::Op::LoadImmediate>(Value(to_underlying(Completion::Type::Normal)));
  1489. generator.emit<Bytecode::Op::StrictlyEquals>(received_completion_type_register);
  1490. generator.emit<Bytecode::Op::JumpConditional>(
  1491. Bytecode::Label { normal_completion_continuation_block },
  1492. Bytecode::Label { throw_completion_continuation_block });
  1493. auto& throw_value_block = generator.make_block();
  1494. auto& return_value_block = generator.make_block();
  1495. generator.switch_to_basic_block(throw_completion_continuation_block);
  1496. generator.emit<Bytecode::Op::LoadImmediate>(Value(to_underlying(Completion::Type::Throw)));
  1497. generator.emit<Bytecode::Op::StrictlyEquals>(received_completion_type_register);
  1498. // If type is not equal to "throw" or "normal", assume it's "return".
  1499. generator.emit<Bytecode::Op::JumpConditional>(
  1500. Bytecode::Label { throw_value_block },
  1501. Bytecode::Label { return_value_block });
  1502. generator.switch_to_basic_block(throw_value_block);
  1503. generator.emit<Bytecode::Op::Load>(received_completion_value_register);
  1504. generator.perform_needed_unwinds<Bytecode::Op::Throw>();
  1505. generator.emit<Bytecode::Op::Throw>();
  1506. generator.switch_to_basic_block(return_value_block);
  1507. generator.emit<Bytecode::Op::Load>(received_completion_value_register);
  1508. generator.perform_needed_unwinds<Bytecode::Op::Yield>();
  1509. generator.emit<Bytecode::Op::Yield>(nullptr);
  1510. generator.switch_to_basic_block(normal_completion_continuation_block);
  1511. generator.emit<Bytecode::Op::Load>(received_completion_value_register);
  1512. return {};
  1513. }
  1514. Bytecode::CodeGenerationErrorOr<void> IfStatement::generate_bytecode(Bytecode::Generator& generator) const
  1515. {
  1516. // test
  1517. // jump if_true (true) true (false) false
  1518. // true
  1519. // jump always (true) end
  1520. // false
  1521. // jump always (true) end
  1522. // end
  1523. auto& true_block = generator.make_block();
  1524. auto& false_block = generator.make_block();
  1525. TRY(m_predicate->generate_bytecode(generator));
  1526. generator.emit<Bytecode::Op::JumpConditional>().set_targets(
  1527. Bytecode::Label { true_block },
  1528. Bytecode::Label { false_block });
  1529. Bytecode::Op::Jump* true_block_jump { nullptr };
  1530. generator.switch_to_basic_block(true_block);
  1531. generator.emit<Bytecode::Op::LoadImmediate>(js_undefined());
  1532. TRY(m_consequent->generate_bytecode(generator));
  1533. if (!generator.is_current_block_terminated())
  1534. true_block_jump = &generator.emit<Bytecode::Op::Jump>();
  1535. generator.switch_to_basic_block(false_block);
  1536. auto& end_block = generator.make_block();
  1537. generator.emit<Bytecode::Op::LoadImmediate>(js_undefined());
  1538. if (m_alternate)
  1539. TRY(m_alternate->generate_bytecode(generator));
  1540. if (!generator.is_current_block_terminated())
  1541. generator.emit<Bytecode::Op::Jump>().set_targets(Bytecode::Label { end_block }, {});
  1542. if (true_block_jump)
  1543. true_block_jump->set_targets(Bytecode::Label { end_block }, {});
  1544. generator.switch_to_basic_block(end_block);
  1545. return {};
  1546. }
  1547. Bytecode::CodeGenerationErrorOr<void> ContinueStatement::generate_bytecode(Bytecode::Generator& generator) const
  1548. {
  1549. // FIXME: Handle finally blocks in a graceful manner
  1550. // We need to execute the finally block, but tell it to resume
  1551. // execution at the designated block
  1552. if (m_target_label.is_null()) {
  1553. generator.generate_continue();
  1554. return {};
  1555. }
  1556. generator.generate_continue(m_target_label);
  1557. return {};
  1558. }
  1559. Bytecode::CodeGenerationErrorOr<void> DebuggerStatement::generate_bytecode(Bytecode::Generator&) const
  1560. {
  1561. return {};
  1562. }
  1563. Bytecode::CodeGenerationErrorOr<void> ConditionalExpression::generate_bytecode(Bytecode::Generator& generator) const
  1564. {
  1565. // test
  1566. // jump if_true (true) true (false) false
  1567. // true
  1568. // jump always (true) end
  1569. // false
  1570. // jump always (true) end
  1571. // end
  1572. auto& true_block = generator.make_block();
  1573. auto& false_block = generator.make_block();
  1574. auto& end_block = generator.make_block();
  1575. TRY(m_test->generate_bytecode(generator));
  1576. generator.emit<Bytecode::Op::JumpConditional>().set_targets(
  1577. Bytecode::Label { true_block },
  1578. Bytecode::Label { false_block });
  1579. generator.switch_to_basic_block(true_block);
  1580. TRY(m_consequent->generate_bytecode(generator));
  1581. generator.emit<Bytecode::Op::Jump>().set_targets(
  1582. Bytecode::Label { end_block },
  1583. {});
  1584. generator.switch_to_basic_block(false_block);
  1585. TRY(m_alternate->generate_bytecode(generator));
  1586. generator.emit<Bytecode::Op::Jump>().set_targets(
  1587. Bytecode::Label { end_block },
  1588. {});
  1589. generator.switch_to_basic_block(end_block);
  1590. return {};
  1591. }
  1592. Bytecode::CodeGenerationErrorOr<void> SequenceExpression::generate_bytecode(Bytecode::Generator& generator) const
  1593. {
  1594. for (auto& expression : m_expressions)
  1595. TRY(expression->generate_bytecode(generator));
  1596. return {};
  1597. }
  1598. Bytecode::CodeGenerationErrorOr<void> TemplateLiteral::generate_bytecode(Bytecode::Generator& generator) const
  1599. {
  1600. auto string_reg = generator.allocate_register();
  1601. for (size_t i = 0; i < m_expressions.size(); i++) {
  1602. TRY(m_expressions[i]->generate_bytecode(generator));
  1603. if (i == 0) {
  1604. generator.emit<Bytecode::Op::Store>(string_reg);
  1605. } else {
  1606. generator.emit<Bytecode::Op::ConcatString>(string_reg);
  1607. }
  1608. }
  1609. generator.emit<Bytecode::Op::Load>(string_reg);
  1610. return {};
  1611. }
  1612. Bytecode::CodeGenerationErrorOr<void> TaggedTemplateLiteral::generate_bytecode(Bytecode::Generator& generator) const
  1613. {
  1614. TRY(m_tag->generate_bytecode(generator));
  1615. auto tag_reg = generator.allocate_register();
  1616. generator.emit<Bytecode::Op::Store>(tag_reg);
  1617. // FIXME: We only need to record the first and last register,
  1618. // due to packing everything in an array, same goes for argument_regs
  1619. // FIXME: Follow
  1620. // 13.2.8.3 GetTemplateObject ( templateLiteral ), https://tc39.es/ecma262/#sec-gettemplateobject
  1621. // more closely, namely:
  1622. // * cache this somehow
  1623. // * add a raw object accessor
  1624. // * freeze array and raw member
  1625. Vector<Bytecode::Register> string_regs;
  1626. auto& expressions = m_template_literal->expressions();
  1627. for (size_t i = 0; i < expressions.size(); ++i) {
  1628. if (i % 2 != 0)
  1629. continue;
  1630. string_regs.append(generator.allocate_register());
  1631. }
  1632. size_t reg_index = 0;
  1633. for (size_t i = 0; i < expressions.size(); ++i) {
  1634. if (i % 2 != 0)
  1635. continue;
  1636. // NOTE: If the string contains invalid escapes we get a null expression here,
  1637. // which we then convert to the expected `undefined` TV. See
  1638. // 12.9.6.1 Static Semantics: TV, https://tc39.es/ecma262/#sec-static-semantics-tv
  1639. if (is<NullLiteral>(expressions[i]))
  1640. generator.emit<Bytecode::Op::LoadImmediate>(js_undefined());
  1641. else
  1642. TRY(expressions[i]->generate_bytecode(generator));
  1643. auto string_reg = string_regs[reg_index++];
  1644. generator.emit<Bytecode::Op::Store>(string_reg);
  1645. }
  1646. if (string_regs.is_empty()) {
  1647. generator.emit<Bytecode::Op::NewArray>();
  1648. } else {
  1649. generator.emit_with_extra_register_slots<Bytecode::Op::NewArray>(2u, AK::Array { string_regs.first(), string_regs.last() });
  1650. }
  1651. auto strings_reg = generator.allocate_register();
  1652. generator.emit<Bytecode::Op::Store>(strings_reg);
  1653. Vector<Bytecode::Register> argument_regs;
  1654. argument_regs.append(strings_reg);
  1655. for (size_t i = 1; i < expressions.size(); i += 2)
  1656. argument_regs.append(generator.allocate_register());
  1657. for (size_t i = 1; i < expressions.size(); i += 2) {
  1658. auto string_reg = argument_regs[1 + i / 2];
  1659. TRY(expressions[i]->generate_bytecode(generator));
  1660. generator.emit<Bytecode::Op::Store>(string_reg);
  1661. }
  1662. Vector<Bytecode::Register> raw_string_regs;
  1663. for ([[maybe_unused]] auto& raw_string : m_template_literal->raw_strings())
  1664. string_regs.append(generator.allocate_register());
  1665. reg_index = 0;
  1666. for (auto& raw_string : m_template_literal->raw_strings()) {
  1667. TRY(raw_string->generate_bytecode(generator));
  1668. auto raw_string_reg = string_regs[reg_index++];
  1669. generator.emit<Bytecode::Op::Store>(raw_string_reg);
  1670. raw_string_regs.append(raw_string_reg);
  1671. }
  1672. if (raw_string_regs.is_empty()) {
  1673. generator.emit<Bytecode::Op::NewArray>();
  1674. } else {
  1675. generator.emit_with_extra_register_slots<Bytecode::Op::NewArray>(2u, AK::Array { raw_string_regs.first(), raw_string_regs.last() });
  1676. }
  1677. auto raw_strings_reg = generator.allocate_register();
  1678. generator.emit<Bytecode::Op::Store>(raw_strings_reg);
  1679. generator.emit<Bytecode::Op::PutById>(strings_reg, generator.intern_identifier("raw"));
  1680. generator.emit<Bytecode::Op::LoadImmediate>(js_undefined());
  1681. auto this_reg = generator.allocate_register();
  1682. generator.emit<Bytecode::Op::Store>(this_reg);
  1683. if (!argument_regs.is_empty())
  1684. generator.emit_with_extra_register_slots<Bytecode::Op::NewArray>(2, AK::Array { argument_regs.first(), argument_regs.last() });
  1685. else
  1686. generator.emit<Bytecode::Op::NewArray>();
  1687. generator.emit<Bytecode::Op::Call>(Bytecode::Op::Call::CallType::Call, tag_reg, this_reg);
  1688. return {};
  1689. }
  1690. Bytecode::CodeGenerationErrorOr<void> UpdateExpression::generate_bytecode(Bytecode::Generator& generator) const
  1691. {
  1692. TRY(generator.emit_load_from_reference(*m_argument));
  1693. Optional<Bytecode::Register> previous_value_for_postfix_reg;
  1694. if (!m_prefixed) {
  1695. previous_value_for_postfix_reg = generator.allocate_register();
  1696. generator.emit<Bytecode::Op::ToNumeric>();
  1697. generator.emit<Bytecode::Op::Store>(*previous_value_for_postfix_reg);
  1698. }
  1699. if (m_op == UpdateOp::Increment)
  1700. generator.emit<Bytecode::Op::Increment>();
  1701. else
  1702. generator.emit<Bytecode::Op::Decrement>();
  1703. TRY(generator.emit_store_to_reference(*m_argument));
  1704. if (!m_prefixed)
  1705. generator.emit<Bytecode::Op::Load>(*previous_value_for_postfix_reg);
  1706. return {};
  1707. }
  1708. Bytecode::CodeGenerationErrorOr<void> ThrowStatement::generate_bytecode(Bytecode::Generator& generator) const
  1709. {
  1710. TRY(m_argument->generate_bytecode(generator));
  1711. generator.perform_needed_unwinds<Bytecode::Op::Throw>();
  1712. generator.emit<Bytecode::Op::Throw>();
  1713. return {};
  1714. }
  1715. Bytecode::CodeGenerationErrorOr<void> BreakStatement::generate_bytecode(Bytecode::Generator& generator) const
  1716. {
  1717. // FIXME: Handle finally blocks in a graceful manner
  1718. // We need to execute the finally block, but tell it to resume
  1719. // execution at the designated block
  1720. if (m_target_label.is_null()) {
  1721. generator.generate_break();
  1722. return {};
  1723. }
  1724. generator.generate_break(m_target_label);
  1725. return {};
  1726. }
  1727. Bytecode::CodeGenerationErrorOr<void> TryStatement::generate_bytecode(Bytecode::Generator& generator) const
  1728. {
  1729. auto& saved_block = generator.current_block();
  1730. Optional<Bytecode::Label> handler_target;
  1731. Optional<Bytecode::Label> finalizer_target;
  1732. Bytecode::BasicBlock* next_block { nullptr };
  1733. if (m_finalizer) {
  1734. // FIXME: See notes in Op.h->ScheduleJump
  1735. auto& finalizer_block = generator.make_block();
  1736. generator.switch_to_basic_block(finalizer_block);
  1737. generator.emit<Bytecode::Op::LeaveUnwindContext>();
  1738. TRY(m_finalizer->generate_bytecode(generator));
  1739. if (!generator.is_current_block_terminated()) {
  1740. next_block = &generator.make_block();
  1741. auto next_target = Bytecode::Label { *next_block };
  1742. generator.emit<Bytecode::Op::ContinuePendingUnwind>(next_target);
  1743. }
  1744. finalizer_target = Bytecode::Label { finalizer_block };
  1745. }
  1746. if (m_finalizer)
  1747. generator.start_boundary(Bytecode::Generator::BlockBoundaryType::ReturnToFinally);
  1748. if (m_handler) {
  1749. auto& handler_block = generator.make_block();
  1750. generator.switch_to_basic_block(handler_block);
  1751. if (!m_finalizer)
  1752. generator.emit<Bytecode::Op::LeaveUnwindContext>();
  1753. generator.begin_variable_scope();
  1754. TRY(m_handler->parameter().visit(
  1755. [&](DeprecatedFlyString const& parameter) -> Bytecode::CodeGenerationErrorOr<void> {
  1756. if (!parameter.is_empty()) {
  1757. auto parameter_identifier = generator.intern_identifier(parameter);
  1758. generator.emit<Bytecode::Op::CreateVariable>(parameter_identifier, Bytecode::Op::EnvironmentMode::Lexical, false);
  1759. generator.emit<Bytecode::Op::SetVariable>(parameter_identifier, Bytecode::Op::SetVariable::InitializationMode::Initialize);
  1760. }
  1761. return {};
  1762. },
  1763. [&](NonnullRefPtr<BindingPattern const> const& binding_pattern) -> Bytecode::CodeGenerationErrorOr<void> {
  1764. auto value_register = generator.allocate_register();
  1765. generator.emit<Bytecode::Op::Store>(value_register);
  1766. TRY(generate_binding_pattern_bytecode(generator, *binding_pattern, Bytecode::Op::SetVariable::InitializationMode::Initialize, value_register, true));
  1767. return {};
  1768. }));
  1769. // Set accumulator to undefined, otherwise we leak the error object through the accumulator.
  1770. // For example: `try { BigInt.call() } catch {}` would result in the error object. Note that
  1771. // the exception _is_ caught here, it just leaks the error object through to the result.
  1772. generator.emit<Bytecode::Op::LoadImmediate>(js_undefined());
  1773. TRY(m_handler->body().generate_bytecode(generator));
  1774. handler_target = Bytecode::Label { handler_block };
  1775. generator.end_variable_scope();
  1776. if (!generator.is_current_block_terminated()) {
  1777. if (m_finalizer) {
  1778. generator.emit<Bytecode::Op::Jump>(finalizer_target);
  1779. } else {
  1780. VERIFY(!next_block);
  1781. next_block = &generator.make_block();
  1782. auto next_target = Bytecode::Label { *next_block };
  1783. generator.emit<Bytecode::Op::Jump>(next_target);
  1784. }
  1785. }
  1786. }
  1787. if (m_finalizer)
  1788. generator.end_boundary(Bytecode::Generator::BlockBoundaryType::ReturnToFinally);
  1789. auto& target_block = generator.make_block();
  1790. generator.switch_to_basic_block(saved_block);
  1791. generator.emit<Bytecode::Op::EnterUnwindContext>(Bytecode::Label { target_block }, handler_target, finalizer_target);
  1792. generator.start_boundary(Bytecode::Generator::BlockBoundaryType::Unwind);
  1793. if (m_finalizer)
  1794. generator.start_boundary(Bytecode::Generator::BlockBoundaryType::ReturnToFinally);
  1795. generator.switch_to_basic_block(target_block);
  1796. TRY(m_block->generate_bytecode(generator));
  1797. if (!generator.is_current_block_terminated()) {
  1798. if (m_finalizer) {
  1799. generator.emit<Bytecode::Op::Jump>(finalizer_target);
  1800. } else {
  1801. if (!next_block)
  1802. next_block = &generator.make_block();
  1803. generator.emit<Bytecode::Op::LeaveUnwindContext>();
  1804. generator.emit<Bytecode::Op::Jump>(Bytecode::Label { *next_block });
  1805. }
  1806. }
  1807. if (m_finalizer)
  1808. generator.end_boundary(Bytecode::Generator::BlockBoundaryType::ReturnToFinally);
  1809. generator.end_boundary(Bytecode::Generator::BlockBoundaryType::Unwind);
  1810. generator.switch_to_basic_block(next_block ? *next_block : saved_block);
  1811. return {};
  1812. }
  1813. Bytecode::CodeGenerationErrorOr<void> SwitchStatement::generate_bytecode(Bytecode::Generator& generator) const
  1814. {
  1815. return generate_labelled_evaluation(generator, {});
  1816. }
  1817. Bytecode::CodeGenerationErrorOr<void> SwitchStatement::generate_labelled_evaluation(Bytecode::Generator& generator, Vector<DeprecatedFlyString> const& label_set) const
  1818. {
  1819. auto discriminant_reg = generator.allocate_register();
  1820. TRY(m_discriminant->generate_bytecode(generator));
  1821. generator.emit<Bytecode::Op::Store>(discriminant_reg);
  1822. Vector<Bytecode::BasicBlock&> case_blocks;
  1823. Bytecode::BasicBlock* default_block { nullptr };
  1824. Bytecode::BasicBlock* next_test_block = &generator.make_block();
  1825. auto has_lexical_declarations = this->has_lexical_declarations();
  1826. if (has_lexical_declarations)
  1827. generator.block_declaration_instantiation(*this);
  1828. generator.emit<Bytecode::Op::Jump>().set_targets(Bytecode::Label { *next_test_block }, {});
  1829. for (auto& switch_case : m_cases) {
  1830. auto& case_block = generator.make_block();
  1831. if (switch_case->test()) {
  1832. generator.switch_to_basic_block(*next_test_block);
  1833. TRY(switch_case->test()->generate_bytecode(generator));
  1834. generator.emit<Bytecode::Op::StrictlyEquals>(discriminant_reg);
  1835. next_test_block = &generator.make_block();
  1836. generator.emit<Bytecode::Op::JumpConditional>().set_targets(Bytecode::Label { case_block }, Bytecode::Label { *next_test_block });
  1837. } else {
  1838. default_block = &case_block;
  1839. }
  1840. case_blocks.append(case_block);
  1841. }
  1842. generator.switch_to_basic_block(*next_test_block);
  1843. auto& end_block = generator.make_block();
  1844. if (default_block != nullptr) {
  1845. generator.emit<Bytecode::Op::Jump>().set_targets(Bytecode::Label { *default_block }, {});
  1846. } else {
  1847. generator.emit<Bytecode::Op::LoadImmediate>(js_undefined());
  1848. generator.emit<Bytecode::Op::Jump>().set_targets(Bytecode::Label { end_block }, {});
  1849. }
  1850. auto current_block = case_blocks.begin();
  1851. generator.begin_breakable_scope(Bytecode::Label { end_block }, label_set);
  1852. for (auto& switch_case : m_cases) {
  1853. generator.switch_to_basic_block(*current_block);
  1854. generator.emit<Bytecode::Op::LoadImmediate>(js_undefined());
  1855. for (auto& statement : switch_case->children()) {
  1856. TRY(statement->generate_bytecode(generator));
  1857. if (generator.is_current_block_terminated())
  1858. break;
  1859. }
  1860. if (!generator.is_current_block_terminated()) {
  1861. auto next_block = current_block;
  1862. next_block++;
  1863. if (next_block.is_end()) {
  1864. generator.emit<Bytecode::Op::Jump>().set_targets(Bytecode::Label { end_block }, {});
  1865. } else {
  1866. generator.emit<Bytecode::Op::Jump>().set_targets(Bytecode::Label { *next_block }, {});
  1867. }
  1868. }
  1869. current_block++;
  1870. }
  1871. generator.end_breakable_scope();
  1872. generator.switch_to_basic_block(end_block);
  1873. if (has_lexical_declarations)
  1874. generator.end_variable_scope();
  1875. return {};
  1876. }
  1877. Bytecode::CodeGenerationErrorOr<void> ClassDeclaration::generate_bytecode(Bytecode::Generator& generator) const
  1878. {
  1879. TRY(m_class_expression->generate_bytecode(generator));
  1880. generator.emit<Bytecode::Op::SetVariable>(generator.intern_identifier(m_class_expression.ptr()->name()), Bytecode::Op::SetVariable::InitializationMode::Initialize);
  1881. return {};
  1882. }
  1883. Bytecode::CodeGenerationErrorOr<void> ClassExpression::generate_bytecode_with_lhs_name(Bytecode::Generator& generator, Optional<DeprecatedFlyString const&> lhs_name) const
  1884. {
  1885. generator.emit<Bytecode::Op::NewClass>(*this, lhs_name);
  1886. return {};
  1887. }
  1888. Bytecode::CodeGenerationErrorOr<void> ClassExpression::generate_bytecode(Bytecode::Generator& generator) const
  1889. {
  1890. return generate_bytecode_with_lhs_name(generator, {});
  1891. }
  1892. Bytecode::CodeGenerationErrorOr<void> SpreadExpression::generate_bytecode(Bytecode::Generator& generator) const
  1893. {
  1894. // NOTE: All users of this should handle the behaviour of this on their own,
  1895. // assuming it returns an Array-like object
  1896. return m_target->generate_bytecode(generator);
  1897. }
  1898. Bytecode::CodeGenerationErrorOr<void> ThisExpression::generate_bytecode(Bytecode::Generator& generator) const
  1899. {
  1900. generator.emit<Bytecode::Op::ResolveThisBinding>();
  1901. return {};
  1902. }
  1903. static void generate_await(Bytecode::Generator& generator)
  1904. {
  1905. VERIFY(generator.is_in_async_function());
  1906. // Transform `await expr` to `yield expr`, see AsyncFunctionDriverWrapper
  1907. // For that we just need to copy most of the code from YieldExpression
  1908. auto received_completion_register = generator.allocate_register();
  1909. auto received_completion_type_register = generator.allocate_register();
  1910. auto received_completion_value_register = generator.allocate_register();
  1911. auto type_identifier = generator.intern_identifier("type");
  1912. auto value_identifier = generator.intern_identifier("value");
  1913. auto& continuation_block = generator.make_block();
  1914. generator.emit<Bytecode::Op::Yield>(Bytecode::Label { continuation_block });
  1915. generator.switch_to_basic_block(continuation_block);
  1916. // The accumulator is set to an object, for example: { "type": 1 (normal), value: 1337 }
  1917. generator.emit<Bytecode::Op::Store>(received_completion_register);
  1918. generator.emit<Bytecode::Op::GetById>(type_identifier);
  1919. generator.emit<Bytecode::Op::Store>(received_completion_type_register);
  1920. generator.emit<Bytecode::Op::Load>(received_completion_register);
  1921. generator.emit<Bytecode::Op::GetById>(value_identifier);
  1922. generator.emit<Bytecode::Op::Store>(received_completion_value_register);
  1923. auto& normal_completion_continuation_block = generator.make_block();
  1924. auto& throw_value_block = generator.make_block();
  1925. generator.emit<Bytecode::Op::LoadImmediate>(Value(to_underlying(Completion::Type::Normal)));
  1926. generator.emit<Bytecode::Op::StrictlyEquals>(received_completion_type_register);
  1927. generator.emit<Bytecode::Op::JumpConditional>(
  1928. Bytecode::Label { normal_completion_continuation_block },
  1929. Bytecode::Label { throw_value_block });
  1930. // Simplification: The only abrupt completion we receive from AsyncFunctionDriverWrapper is Type::Throw
  1931. // So we do not need to account for the Type::Return path
  1932. generator.switch_to_basic_block(throw_value_block);
  1933. generator.emit<Bytecode::Op::Load>(received_completion_value_register);
  1934. generator.perform_needed_unwinds<Bytecode::Op::Throw>();
  1935. generator.emit<Bytecode::Op::Throw>();
  1936. generator.switch_to_basic_block(normal_completion_continuation_block);
  1937. generator.emit<Bytecode::Op::Load>(received_completion_value_register);
  1938. }
  1939. Bytecode::CodeGenerationErrorOr<void> AwaitExpression::generate_bytecode(Bytecode::Generator& generator) const
  1940. {
  1941. TRY(m_argument->generate_bytecode(generator));
  1942. generate_await(generator);
  1943. return {};
  1944. }
  1945. Bytecode::CodeGenerationErrorOr<void> WithStatement::generate_bytecode(Bytecode::Generator& generator) const
  1946. {
  1947. TRY(m_object->generate_bytecode(generator));
  1948. generator.emit<Bytecode::Op::EnterObjectEnvironment>();
  1949. // EnterObjectEnvironment sets the running execution context's lexical_environment to a new Object Environment.
  1950. generator.start_boundary(Bytecode::Generator::BlockBoundaryType::LeaveLexicalEnvironment);
  1951. TRY(m_body->generate_bytecode(generator));
  1952. generator.end_boundary(Bytecode::Generator::BlockBoundaryType::LeaveLexicalEnvironment);
  1953. if (!generator.is_current_block_terminated())
  1954. generator.emit<Bytecode::Op::LeaveLexicalEnvironment>();
  1955. return {};
  1956. }
  1957. enum class LHSKind {
  1958. Assignment,
  1959. VarBinding,
  1960. LexicalBinding,
  1961. };
  1962. enum class IterationKind {
  1963. Enumerate,
  1964. Iterate,
  1965. AsyncIterate,
  1966. };
  1967. // 14.7.5.6 ForIn/OfHeadEvaluation ( uninitializedBoundNames, expr, iterationKind ), https://tc39.es/ecma262/#sec-runtime-semantics-forinofheadevaluation
  1968. struct ForInOfHeadEvaluationResult {
  1969. bool is_destructuring { false };
  1970. LHSKind lhs_kind { LHSKind::Assignment };
  1971. };
  1972. static Bytecode::CodeGenerationErrorOr<ForInOfHeadEvaluationResult> for_in_of_head_evaluation(Bytecode::Generator& generator, IterationKind iteration_kind, Variant<NonnullRefPtr<ASTNode const>, NonnullRefPtr<BindingPattern const>> const& lhs, NonnullRefPtr<ASTNode const> const& rhs)
  1973. {
  1974. ForInOfHeadEvaluationResult result {};
  1975. bool entered_lexical_scope = false;
  1976. if (auto* ast_ptr = lhs.get_pointer<NonnullRefPtr<ASTNode const>>(); ast_ptr && is<VariableDeclaration>(**ast_ptr)) {
  1977. // Runtime Semantics: ForInOfLoopEvaluation, for any of:
  1978. // ForInOfStatement : for ( var ForBinding in Expression ) Statement
  1979. // ForInOfStatement : for ( ForDeclaration in Expression ) Statement
  1980. // ForInOfStatement : for ( var ForBinding of AssignmentExpression ) Statement
  1981. // ForInOfStatement : for ( ForDeclaration of AssignmentExpression ) Statement
  1982. auto& variable_declaration = static_cast<VariableDeclaration const&>(**ast_ptr);
  1983. result.is_destructuring = variable_declaration.declarations().first()->target().has<NonnullRefPtr<BindingPattern const>>();
  1984. result.lhs_kind = variable_declaration.is_lexical_declaration() ? LHSKind::LexicalBinding : LHSKind::VarBinding;
  1985. // 1. Let oldEnv be the running execution context's LexicalEnvironment.
  1986. // NOTE: 'uninitializedBoundNames' refers to the lexical bindings (i.e. Const/Let) present in the second and last form.
  1987. // 2. If uninitializedBoundNames is not an empty List, then
  1988. if (variable_declaration.declaration_kind() != DeclarationKind::Var) {
  1989. entered_lexical_scope = true;
  1990. // a. Assert: uninitializedBoundNames has no duplicate entries.
  1991. // b. Let newEnv be NewDeclarativeEnvironment(oldEnv).
  1992. generator.begin_variable_scope();
  1993. // c. For each String name of uninitializedBoundNames, do
  1994. // NOTE: Nothing in the callback throws an exception.
  1995. MUST(variable_declaration.for_each_bound_name([&](auto const& name) {
  1996. // i. Perform ! newEnv.CreateMutableBinding(name, false).
  1997. auto identifier = generator.intern_identifier(name);
  1998. generator.emit<Bytecode::Op::CreateVariable>(identifier, Bytecode::Op::EnvironmentMode::Lexical, false);
  1999. }));
  2000. // d. Set the running execution context's LexicalEnvironment to newEnv.
  2001. // NOTE: Done by CreateLexicalEnvironment.
  2002. }
  2003. } else {
  2004. // Runtime Semantics: ForInOfLoopEvaluation, for any of:
  2005. // ForInOfStatement : for ( LeftHandSideExpression in Expression ) Statement
  2006. // ForInOfStatement : for ( LeftHandSideExpression of AssignmentExpression ) Statement
  2007. result.lhs_kind = LHSKind::Assignment;
  2008. }
  2009. // 3. Let exprRef be the result of evaluating expr.
  2010. TRY(rhs->generate_bytecode(generator));
  2011. // 4. Set the running execution context's LexicalEnvironment to oldEnv.
  2012. if (entered_lexical_scope)
  2013. generator.end_variable_scope();
  2014. // 5. Let exprValue be ? GetValue(exprRef).
  2015. // NOTE: No need to store this anywhere.
  2016. // 6. If iterationKind is enumerate, then
  2017. if (iteration_kind == IterationKind::Enumerate) {
  2018. // a. If exprValue is undefined or null, then
  2019. auto& nullish_block = generator.make_block();
  2020. auto& continuation_block = generator.make_block();
  2021. auto& jump = generator.emit<Bytecode::Op::JumpNullish>();
  2022. jump.set_targets(Bytecode::Label { nullish_block }, Bytecode::Label { continuation_block });
  2023. // i. Return Completion Record { [[Type]]: break, [[Value]]: empty, [[Target]]: empty }.
  2024. generator.switch_to_basic_block(nullish_block);
  2025. generator.generate_break();
  2026. generator.switch_to_basic_block(continuation_block);
  2027. // b. Let obj be ! ToObject(exprValue).
  2028. // NOTE: GetObjectPropertyIterator does this.
  2029. // c. Let iterator be EnumerateObjectProperties(obj).
  2030. // d. Let nextMethod be ! GetV(iterator, "next").
  2031. // e. Return the Iterator Record { [[Iterator]]: iterator, [[NextMethod]]: nextMethod, [[Done]]: false }.
  2032. generator.emit<Bytecode::Op::GetObjectPropertyIterator>();
  2033. }
  2034. // 7. Else,
  2035. else {
  2036. // a. Assert: iterationKind is iterate or async-iterate.
  2037. // b. If iterationKind is async-iterate, let iteratorHint be async.
  2038. // c. Else, let iteratorHint be sync.
  2039. auto iterator_hint = iteration_kind == IterationKind::AsyncIterate ? IteratorHint::Async : IteratorHint::Sync;
  2040. // d. Return ? GetIterator(exprValue, iteratorHint).
  2041. generator.emit<Bytecode::Op::GetIterator>(iterator_hint);
  2042. }
  2043. return result;
  2044. }
  2045. // 14.7.5.7 ForIn/OfBodyEvaluation ( lhs, stmt, iteratorRecord, iterationKind, lhsKind, labelSet [ , iteratorKind ] ), https://tc39.es/ecma262/#sec-runtime-semantics-forin-div-ofbodyevaluation-lhs-stmt-iterator-lhskind-labelset
  2046. static Bytecode::CodeGenerationErrorOr<void> for_in_of_body_evaluation(Bytecode::Generator& generator, ASTNode const& node, Variant<NonnullRefPtr<ASTNode const>, NonnullRefPtr<BindingPattern const>> const& lhs, ASTNode const& body, ForInOfHeadEvaluationResult const& head_result, Vector<DeprecatedFlyString> const& label_set, Bytecode::BasicBlock& loop_end, Bytecode::BasicBlock& loop_update, IteratorHint iterator_kind = IteratorHint::Sync)
  2047. {
  2048. auto iterator_register = generator.allocate_register();
  2049. generator.emit<Bytecode::Op::Store>(iterator_register);
  2050. // 1. If iteratorKind is not present, set iteratorKind to sync.
  2051. // 2. Let oldEnv be the running execution context's LexicalEnvironment.
  2052. bool has_lexical_binding = false;
  2053. // 3. Let V be undefined.
  2054. // NOTE: We don't need 'V' as the resulting value will naturally flow through via the accumulator register.
  2055. // 4. Let destructuring be IsDestructuring of lhs.
  2056. auto destructuring = head_result.is_destructuring;
  2057. // 5. If destructuring is true and if lhsKind is assignment, then
  2058. if (destructuring && head_result.lhs_kind == LHSKind::Assignment) {
  2059. // a. Assert: lhs is a LeftHandSideExpression.
  2060. // b. Let assignmentPattern be the AssignmentPattern that is covered by lhs.
  2061. // FIXME: Implement this.
  2062. return Bytecode::CodeGenerationError {
  2063. &node,
  2064. "Unimplemented: assignment destructuring in for/of"sv,
  2065. };
  2066. }
  2067. // 6. Repeat,
  2068. generator.emit<Bytecode::Op::Jump>(Bytecode::Label { loop_update });
  2069. generator.switch_to_basic_block(loop_update);
  2070. generator.begin_continuable_scope(Bytecode::Label { loop_update }, label_set);
  2071. // a. Let nextResult be ? Call(iteratorRecord.[[NextMethod]], iteratorRecord.[[Iterator]]).
  2072. generator.emit<Bytecode::Op::Load>(iterator_register);
  2073. generator.emit<Bytecode::Op::IteratorNext>();
  2074. // b. If iteratorKind is async, set nextResult to ? Await(nextResult).
  2075. if (iterator_kind == IteratorHint::Async)
  2076. generate_await(generator);
  2077. // c. If Type(nextResult) is not Object, throw a TypeError exception.
  2078. generator.emit<Bytecode::Op::ThrowIfNotObject>();
  2079. // d. Let done be ? IteratorComplete(nextResult).
  2080. auto iterator_result_register = generator.allocate_register();
  2081. generator.emit<Bytecode::Op::Store>(iterator_result_register);
  2082. generator.emit<Bytecode::Op::IteratorResultDone>();
  2083. // e. If done is true, return V.
  2084. auto& loop_continue = generator.make_block();
  2085. generator.emit<Bytecode::Op::JumpConditional>().set_targets(Bytecode::Label { loop_end }, Bytecode::Label { loop_continue });
  2086. generator.switch_to_basic_block(loop_continue);
  2087. // f. Let nextValue be ? IteratorValue(nextResult).
  2088. generator.emit<Bytecode::Op::Load>(iterator_result_register);
  2089. generator.emit<Bytecode::Op::IteratorResultValue>();
  2090. // g. If lhsKind is either assignment or varBinding, then
  2091. if (head_result.lhs_kind != LHSKind::LexicalBinding) {
  2092. // i. If destructuring is false, then
  2093. if (!destructuring) {
  2094. // 1. Let lhsRef be the result of evaluating lhs. (It may be evaluated repeatedly.)
  2095. // NOTE: We're skipping all the completion stuff that the spec does, as the unwinding mechanism will take case of doing that.
  2096. if (head_result.lhs_kind == LHSKind::VarBinding) {
  2097. auto& declaration = static_cast<VariableDeclaration const&>(*lhs.get<NonnullRefPtr<ASTNode const>>());
  2098. VERIFY(declaration.declarations().size() == 1);
  2099. TRY(assign_accumulator_to_variable_declarator(generator, declaration.declarations().first(), declaration));
  2100. } else {
  2101. if (auto ptr = lhs.get_pointer<NonnullRefPtr<ASTNode const>>()) {
  2102. TRY(generator.emit_store_to_reference(**ptr));
  2103. } else {
  2104. auto& binding_pattern = lhs.get<NonnullRefPtr<BindingPattern const>>();
  2105. auto value_register = generator.allocate_register();
  2106. generator.emit<Bytecode::Op::Store>(value_register);
  2107. TRY(generate_binding_pattern_bytecode(generator, *binding_pattern, Bytecode::Op::SetVariable::InitializationMode::Set, value_register, false));
  2108. }
  2109. }
  2110. }
  2111. }
  2112. // h. Else,
  2113. else {
  2114. // i. Assert: lhsKind is lexicalBinding.
  2115. // ii. Assert: lhs is a ForDeclaration.
  2116. // iii. Let iterationEnv be NewDeclarativeEnvironment(oldEnv).
  2117. // iv. Perform ForDeclarationBindingInstantiation of lhs with argument iterationEnv.
  2118. // v. Set the running execution context's LexicalEnvironment to iterationEnv.
  2119. generator.begin_variable_scope();
  2120. has_lexical_binding = true;
  2121. // 14.7.5.4 Runtime Semantics: ForDeclarationBindingInstantiation, https://tc39.es/ecma262/#sec-runtime-semantics-fordeclarationbindinginstantiation
  2122. // 1. Assert: environment is a declarative Environment Record.
  2123. // NOTE: We just made it.
  2124. auto& variable_declaration = static_cast<VariableDeclaration const&>(*lhs.get<NonnullRefPtr<ASTNode const>>());
  2125. // 2. For each element name of the BoundNames of ForBinding, do
  2126. // NOTE: Nothing in the callback throws an exception.
  2127. MUST(variable_declaration.for_each_bound_name([&](auto const& name) {
  2128. auto identifier = generator.intern_identifier(name);
  2129. // a. If IsConstantDeclaration of LetOrConst is true, then
  2130. if (variable_declaration.is_constant_declaration()) {
  2131. // i. Perform ! environment.CreateImmutableBinding(name, true).
  2132. generator.emit<Bytecode::Op::CreateVariable>(identifier, Bytecode::Op::EnvironmentMode::Lexical, true);
  2133. }
  2134. // b. Else,
  2135. else {
  2136. // i. Perform ! environment.CreateMutableBinding(name, false).
  2137. generator.emit<Bytecode::Op::CreateVariable>(identifier, Bytecode::Op::EnvironmentMode::Lexical, false);
  2138. }
  2139. }));
  2140. // 3. Return unused.
  2141. // NOTE: No need to do that as we've inlined this.
  2142. // vi. If destructuring is false, then
  2143. if (!destructuring) {
  2144. // 1. Assert: lhs binds a single name.
  2145. // 2. Let lhsName be the sole element of BoundNames of lhs.
  2146. auto lhs_name = variable_declaration.declarations().first()->target().get<NonnullRefPtr<Identifier const>>()->string();
  2147. // 3. Let lhsRef be ! ResolveBinding(lhsName).
  2148. // NOTE: We're skipping all the completion stuff that the spec does, as the unwinding mechanism will take case of doing that.
  2149. auto identifier = generator.intern_identifier(lhs_name);
  2150. generator.emit<Bytecode::Op::SetVariable>(identifier, Bytecode::Op::SetVariable::InitializationMode::Initialize, Bytecode::Op::EnvironmentMode::Lexical);
  2151. }
  2152. }
  2153. // i. If destructuring is false, then
  2154. if (!destructuring) {
  2155. // i. If lhsRef is an abrupt completion, then
  2156. // 1. Let status be lhsRef.
  2157. // ii. Else if lhsKind is lexicalBinding, then
  2158. // 1. Let status be Completion(InitializeReferencedBinding(lhsRef, nextValue)).
  2159. // iii. Else,
  2160. // 1. Let status be Completion(PutValue(lhsRef, nextValue)).
  2161. // NOTE: This is performed above.
  2162. }
  2163. // j. Else,
  2164. else {
  2165. // FIXME: i. If lhsKind is assignment, then
  2166. // 1. Let status be Completion(DestructuringAssignmentEvaluation of assignmentPattern with argument nextValue).
  2167. // ii. Else if lhsKind is varBinding, then
  2168. // 1. Assert: lhs is a ForBinding.
  2169. // 2. Let status be Completion(BindingInitialization of lhs with arguments nextValue and undefined).
  2170. // iii. Else,
  2171. // 1. Assert: lhsKind is lexicalBinding.
  2172. // 2. Assert: lhs is a ForDeclaration.
  2173. // 3. Let status be Completion(ForDeclarationBindingInitialization of lhs with arguments nextValue and iterationEnv).
  2174. if (head_result.lhs_kind == LHSKind::VarBinding || head_result.lhs_kind == LHSKind::LexicalBinding) {
  2175. auto& declaration = static_cast<VariableDeclaration const&>(*lhs.get<NonnullRefPtr<ASTNode const>>());
  2176. VERIFY(declaration.declarations().size() == 1);
  2177. auto& binding_pattern = declaration.declarations().first()->target().get<NonnullRefPtr<BindingPattern const>>();
  2178. auto value_register = generator.allocate_register();
  2179. generator.emit<Bytecode::Op::Store>(value_register);
  2180. TRY(generate_binding_pattern_bytecode(generator, *binding_pattern, head_result.lhs_kind == LHSKind::VarBinding ? Bytecode::Op::SetVariable::InitializationMode::Set : Bytecode::Op::SetVariable::InitializationMode::Initialize, value_register, false));
  2181. } else {
  2182. return Bytecode::CodeGenerationError {
  2183. &node,
  2184. "Unimplemented: assignment destructuring in for/of"sv,
  2185. };
  2186. }
  2187. }
  2188. // FIXME: Implement iteration closure.
  2189. // k. If status is an abrupt completion, then
  2190. // i. Set the running execution context's LexicalEnvironment to oldEnv.
  2191. // ii. If iteratorKind is async, return ? AsyncIteratorClose(iteratorRecord, status).
  2192. // iii. If iterationKind is enumerate, then
  2193. // 1. Return ? status.
  2194. // iv. Else,
  2195. // 1. Assert: iterationKind is iterate.
  2196. // 2. Return ? IteratorClose(iteratorRecord, status).
  2197. // l. Let result be the result of evaluating stmt.
  2198. TRY(body.generate_bytecode(generator));
  2199. // m. Set the running execution context's LexicalEnvironment to oldEnv.
  2200. if (has_lexical_binding)
  2201. generator.end_variable_scope();
  2202. generator.end_continuable_scope();
  2203. generator.end_breakable_scope();
  2204. // NOTE: If we're here, then the loop definitely continues.
  2205. // n. If LoopContinues(result, labelSet) is false, then
  2206. // i. If iterationKind is enumerate, then
  2207. // 1. Return ? UpdateEmpty(result, V).
  2208. // ii. Else,
  2209. // 1. Assert: iterationKind is iterate.
  2210. // 2. Set status to Completion(UpdateEmpty(result, V)).
  2211. // 3. If iteratorKind is async, return ? AsyncIteratorClose(iteratorRecord, status).
  2212. // 4. Return ? IteratorClose(iteratorRecord, status).
  2213. // o. If result.[[Value]] is not empty, set V to result.[[Value]].
  2214. // The body can contain an unconditional block terminator (e.g. return, throw), so we have to check for that before generating the Jump.
  2215. if (!generator.is_current_block_terminated())
  2216. generator.emit<Bytecode::Op::Jump>().set_targets(Bytecode::Label { loop_update }, {});
  2217. generator.switch_to_basic_block(loop_end);
  2218. return {};
  2219. }
  2220. Bytecode::CodeGenerationErrorOr<void> ForInStatement::generate_bytecode(Bytecode::Generator& generator) const
  2221. {
  2222. return generate_labelled_evaluation(generator, {});
  2223. }
  2224. // 14.7.5.5 Runtime Semantics: ForInOfLoopEvaluation, https://tc39.es/ecma262/#sec-runtime-semantics-forinofloopevaluation
  2225. Bytecode::CodeGenerationErrorOr<void> ForInStatement::generate_labelled_evaluation(Bytecode::Generator& generator, Vector<DeprecatedFlyString> const& label_set) const
  2226. {
  2227. auto& loop_end = generator.make_block();
  2228. auto& loop_update = generator.make_block();
  2229. generator.begin_breakable_scope(Bytecode::Label { loop_end }, label_set);
  2230. auto head_result = TRY(for_in_of_head_evaluation(generator, IterationKind::Enumerate, m_lhs, m_rhs));
  2231. // Now perform the rest of ForInOfLoopEvaluation, given that the accumulator holds the iterator we're supposed to iterate over.
  2232. return for_in_of_body_evaluation(generator, *this, m_lhs, body(), head_result, label_set, loop_end, loop_update);
  2233. }
  2234. Bytecode::CodeGenerationErrorOr<void> ForOfStatement::generate_bytecode(Bytecode::Generator& generator) const
  2235. {
  2236. return generate_labelled_evaluation(generator, {});
  2237. }
  2238. Bytecode::CodeGenerationErrorOr<void> ForOfStatement::generate_labelled_evaluation(Bytecode::Generator& generator, Vector<DeprecatedFlyString> const& label_set) const
  2239. {
  2240. auto& loop_end = generator.make_block();
  2241. auto& loop_update = generator.make_block();
  2242. generator.begin_breakable_scope(Bytecode::Label { loop_end }, label_set);
  2243. auto head_result = TRY(for_in_of_head_evaluation(generator, IterationKind::Iterate, m_lhs, m_rhs));
  2244. // Now perform the rest of ForInOfLoopEvaluation, given that the accumulator holds the iterator we're supposed to iterate over.
  2245. return for_in_of_body_evaluation(generator, *this, m_lhs, body(), head_result, label_set, loop_end, loop_update);
  2246. }
  2247. Bytecode::CodeGenerationErrorOr<void> ForAwaitOfStatement::generate_bytecode(Bytecode::Generator& generator) const
  2248. {
  2249. return generate_labelled_evaluation(generator, {});
  2250. }
  2251. Bytecode::CodeGenerationErrorOr<void> ForAwaitOfStatement::generate_labelled_evaluation(Bytecode::Generator& generator, Vector<DeprecatedFlyString> const& label_set) const
  2252. {
  2253. auto& loop_end = generator.make_block();
  2254. auto& loop_update = generator.make_block();
  2255. generator.begin_breakable_scope(Bytecode::Label { loop_end }, label_set);
  2256. auto head_result = TRY(for_in_of_head_evaluation(generator, IterationKind::AsyncIterate, m_lhs, m_rhs));
  2257. // Now perform the rest of ForInOfLoopEvaluation, given that the accumulator holds the iterator we're supposed to iterate over.
  2258. return for_in_of_body_evaluation(generator, *this, m_lhs, m_body, head_result, label_set, loop_end, loop_update, IteratorHint::Async);
  2259. }
  2260. // 13.3.12.1 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-meta-properties-runtime-semantics-evaluation
  2261. Bytecode::CodeGenerationErrorOr<void> MetaProperty::generate_bytecode(Bytecode::Generator& generator) const
  2262. {
  2263. // NewTarget : new . target
  2264. if (m_type == MetaProperty::Type::NewTarget) {
  2265. // 1. Return GetNewTarget().
  2266. generator.emit<Bytecode::Op::GetNewTarget>();
  2267. return {};
  2268. }
  2269. // ImportMeta : import . meta
  2270. if (m_type == MetaProperty::Type::ImportMeta) {
  2271. return Bytecode::CodeGenerationError {
  2272. this,
  2273. "Unimplemented meta property: import.meta"sv,
  2274. };
  2275. }
  2276. VERIFY_NOT_REACHED();
  2277. }
  2278. Bytecode::CodeGenerationErrorOr<void> ClassFieldInitializerStatement::generate_bytecode(Bytecode::Generator& generator) const
  2279. {
  2280. TRY(generator.emit_named_evaluation_if_anonymous_function(*m_expression, m_class_field_identifier_name));
  2281. generator.perform_needed_unwinds<Bytecode::Op::Return>();
  2282. generator.emit<Bytecode::Op::Return>();
  2283. return {};
  2284. }
  2285. static Bytecode::CodeGenerationErrorOr<void> generate_optional_chain(Bytecode::Generator& generator, OptionalChain const& optional_chain, Bytecode::Register current_value_register, Bytecode::Register current_base_register)
  2286. {
  2287. if (is<MemberExpression>(optional_chain.base())) {
  2288. auto& member_expression = static_cast<MemberExpression const&>(optional_chain.base());
  2289. TRY(get_base_and_value_from_member_expression(generator, member_expression, current_base_register));
  2290. } else if (is<OptionalChain>(optional_chain.base())) {
  2291. auto& sub_optional_chain = static_cast<OptionalChain const&>(optional_chain.base());
  2292. TRY(generate_optional_chain(generator, sub_optional_chain, current_value_register, current_base_register));
  2293. } else {
  2294. TRY(optional_chain.base().generate_bytecode(generator));
  2295. }
  2296. generator.emit<Bytecode::Op::Store>(current_value_register);
  2297. auto& load_undefined_and_jump_to_end_block = generator.make_block();
  2298. auto& end_block = generator.make_block();
  2299. for (auto& reference : optional_chain.references()) {
  2300. auto is_optional = reference.visit([](auto& ref) { return ref.mode; }) == OptionalChain::Mode::Optional;
  2301. if (is_optional) {
  2302. auto& not_nullish_block = generator.make_block();
  2303. generator.emit<Bytecode::Op::JumpNullish>(
  2304. Bytecode::Label { load_undefined_and_jump_to_end_block },
  2305. Bytecode::Label { not_nullish_block });
  2306. generator.switch_to_basic_block(not_nullish_block);
  2307. }
  2308. TRY(reference.visit(
  2309. [&](OptionalChain::Call const& call) -> Bytecode::CodeGenerationErrorOr<void> {
  2310. TRY(arguments_to_array_for_call(generator, call.arguments));
  2311. generator.emit<Bytecode::Op::Call>(Bytecode::Op::Call::CallType::Call, current_value_register, current_base_register);
  2312. generator.emit<Bytecode::Op::Store>(current_value_register);
  2313. generator.emit<Bytecode::Op::LoadImmediate>(js_undefined());
  2314. generator.emit<Bytecode::Op::Store>(current_base_register);
  2315. generator.emit<Bytecode::Op::Load>(current_value_register);
  2316. return {};
  2317. },
  2318. [&](OptionalChain::ComputedReference const& ref) -> Bytecode::CodeGenerationErrorOr<void> {
  2319. generator.emit<Bytecode::Op::Store>(current_base_register);
  2320. TRY(ref.expression->generate_bytecode(generator));
  2321. generator.emit<Bytecode::Op::GetByValue>(current_base_register);
  2322. generator.emit<Bytecode::Op::Store>(current_value_register);
  2323. return {};
  2324. },
  2325. [&](OptionalChain::MemberReference const& ref) -> Bytecode::CodeGenerationErrorOr<void> {
  2326. generator.emit<Bytecode::Op::Store>(current_base_register);
  2327. generator.emit<Bytecode::Op::GetById>(generator.intern_identifier(ref.identifier->string()));
  2328. generator.emit<Bytecode::Op::Store>(current_value_register);
  2329. return {};
  2330. },
  2331. [&](OptionalChain::PrivateMemberReference const& ref) -> Bytecode::CodeGenerationErrorOr<void> {
  2332. generator.emit<Bytecode::Op::Store>(current_base_register);
  2333. generator.emit<Bytecode::Op::GetPrivateById>(generator.intern_identifier(ref.private_identifier->string()));
  2334. generator.emit<Bytecode::Op::Store>(current_value_register);
  2335. return {};
  2336. }));
  2337. }
  2338. generator.emit<Bytecode::Op::Jump>(Bytecode::Label { end_block });
  2339. generator.switch_to_basic_block(load_undefined_and_jump_to_end_block);
  2340. generator.emit<Bytecode::Op::LoadImmediate>(js_undefined());
  2341. generator.emit<Bytecode::Op::Jump>(Bytecode::Label { end_block });
  2342. generator.switch_to_basic_block(end_block);
  2343. return {};
  2344. }
  2345. Bytecode::CodeGenerationErrorOr<void> OptionalChain::generate_bytecode(Bytecode::Generator& generator) const
  2346. {
  2347. auto current_base_register = generator.allocate_register();
  2348. auto current_value_register = generator.allocate_register();
  2349. generator.emit<Bytecode::Op::LoadImmediate>(js_undefined());
  2350. generator.emit<Bytecode::Op::Store>(current_base_register);
  2351. return generate_optional_chain(generator, *this, current_value_register, current_base_register);
  2352. }
  2353. Bytecode::CodeGenerationErrorOr<void> ImportCall::generate_bytecode(Bytecode::Generator& generator) const
  2354. {
  2355. TRY(m_specifier->generate_bytecode(generator));
  2356. auto specifier_reg = generator.allocate_register();
  2357. generator.emit<Bytecode::Op::Store>(specifier_reg);
  2358. if (m_options) {
  2359. TRY(m_options->generate_bytecode(generator));
  2360. } else {
  2361. generator.emit<Bytecode::Op::LoadImmediate>(js_undefined());
  2362. }
  2363. auto options_reg = generator.allocate_register();
  2364. generator.emit<Bytecode::Op::Store>(options_reg);
  2365. generator.emit<Bytecode::Op::ImportCall>(specifier_reg, options_reg);
  2366. return {};
  2367. }
  2368. Bytecode::CodeGenerationErrorOr<void> ExportStatement::generate_bytecode(Bytecode::Generator& generator) const
  2369. {
  2370. if (!is_default_export()) {
  2371. if (m_statement) {
  2372. return m_statement->generate_bytecode(generator);
  2373. }
  2374. return {};
  2375. }
  2376. VERIFY(m_statement);
  2377. if (is<FunctionDeclaration>(*m_statement) || is<ClassDeclaration>(*m_statement)) {
  2378. return m_statement->generate_bytecode(generator);
  2379. }
  2380. if (is<ClassExpression>(*m_statement)) {
  2381. TRY(m_statement->generate_bytecode(generator));
  2382. if (!static_cast<ClassExpression const&>(*m_statement).has_name())
  2383. generator.emit<Bytecode::Op::SetVariable>(generator.intern_identifier(ExportStatement::local_name_for_default), Bytecode::Op::SetVariable::InitializationMode::Initialize);
  2384. return {};
  2385. }
  2386. // ExportDeclaration : export default AssignmentExpression ;
  2387. VERIFY(is<Expression>(*m_statement));
  2388. TRY(generator.emit_named_evaluation_if_anonymous_function(static_cast<Expression const&>(*m_statement), DeprecatedFlyString("default"sv)));
  2389. generator.emit<Bytecode::Op::SetVariable>(generator.intern_identifier(ExportStatement::local_name_for_default), Bytecode::Op::SetVariable::InitializationMode::Initialize);
  2390. return {};
  2391. }
  2392. Bytecode::CodeGenerationErrorOr<void> ImportStatement::generate_bytecode(Bytecode::Generator&) const
  2393. {
  2394. return {};
  2395. }
  2396. }