AST.cpp 200 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237223822392240224122422243224422452246224722482249225022512252225322542255225622572258225922602261226222632264226522662267226822692270227122722273227422752276227722782279228022812282228322842285228622872288228922902291229222932294229522962297229822992300230123022303230423052306230723082309231023112312231323142315231623172318231923202321232223232324232523262327232823292330233123322333233423352336233723382339234023412342234323442345234623472348234923502351235223532354235523562357235823592360236123622363236423652366236723682369237023712372237323742375237623772378237923802381238223832384238523862387238823892390239123922393239423952396239723982399240024012402240324042405240624072408240924102411241224132414241524162417241824192420242124222423242424252426242724282429243024312432243324342435243624372438243924402441244224432444244524462447244824492450245124522453245424552456245724582459246024612462246324642465246624672468246924702471247224732474247524762477247824792480248124822483248424852486248724882489249024912492249324942495249624972498249925002501250225032504250525062507250825092510251125122513251425152516251725182519252025212522252325242525252625272528252925302531253225332534253525362537253825392540254125422543254425452546254725482549255025512552255325542555255625572558255925602561256225632564256525662567256825692570257125722573257425752576257725782579258025812582258325842585258625872588258925902591259225932594259525962597259825992600260126022603260426052606260726082609261026112612261326142615261626172618261926202621262226232624262526262627262826292630263126322633263426352636263726382639264026412642264326442645264626472648264926502651265226532654265526562657265826592660266126622663266426652666266726682669267026712672267326742675267626772678267926802681268226832684268526862687268826892690269126922693269426952696269726982699270027012702270327042705270627072708270927102711271227132714271527162717271827192720272127222723272427252726272727282729273027312732273327342735273627372738273927402741274227432744274527462747274827492750275127522753275427552756275727582759276027612762276327642765276627672768276927702771277227732774277527762777277827792780278127822783278427852786278727882789279027912792279327942795279627972798279928002801280228032804280528062807280828092810281128122813281428152816281728182819282028212822282328242825282628272828282928302831283228332834283528362837283828392840284128422843284428452846284728482849285028512852285328542855285628572858285928602861286228632864286528662867286828692870287128722873287428752876287728782879288028812882288328842885288628872888288928902891289228932894289528962897289828992900290129022903290429052906290729082909291029112912291329142915291629172918291929202921292229232924292529262927292829292930293129322933293429352936293729382939294029412942294329442945294629472948294929502951295229532954295529562957295829592960296129622963296429652966296729682969297029712972297329742975297629772978297929802981298229832984298529862987298829892990299129922993299429952996299729982999300030013002300330043005300630073008300930103011301230133014301530163017301830193020302130223023302430253026302730283029303030313032303330343035303630373038303930403041304230433044304530463047304830493050305130523053305430553056305730583059306030613062306330643065306630673068306930703071307230733074307530763077307830793080308130823083308430853086308730883089309030913092309330943095309630973098309931003101310231033104310531063107310831093110311131123113311431153116311731183119312031213122312331243125312631273128312931303131313231333134313531363137313831393140314131423143314431453146314731483149315031513152315331543155315631573158315931603161316231633164316531663167316831693170317131723173317431753176317731783179318031813182318331843185318631873188318931903191319231933194319531963197319831993200320132023203320432053206320732083209321032113212321332143215321632173218321932203221322232233224322532263227322832293230323132323233323432353236323732383239324032413242324332443245324632473248324932503251325232533254325532563257325832593260326132623263326432653266326732683269327032713272327332743275327632773278327932803281328232833284328532863287328832893290329132923293329432953296329732983299330033013302330333043305330633073308330933103311331233133314331533163317331833193320332133223323332433253326332733283329333033313332333333343335333633373338333933403341334233433344334533463347334833493350335133523353335433553356335733583359336033613362336333643365336633673368336933703371337233733374337533763377337833793380338133823383338433853386338733883389339033913392339333943395339633973398339934003401340234033404340534063407340834093410341134123413341434153416341734183419342034213422342334243425342634273428342934303431343234333434343534363437343834393440344134423443344434453446344734483449345034513452345334543455345634573458345934603461346234633464346534663467346834693470347134723473347434753476347734783479348034813482348334843485348634873488348934903491349234933494349534963497349834993500350135023503350435053506350735083509351035113512351335143515351635173518351935203521352235233524352535263527352835293530353135323533353435353536353735383539354035413542354335443545354635473548354935503551355235533554355535563557355835593560356135623563356435653566356735683569357035713572357335743575357635773578357935803581358235833584358535863587358835893590359135923593359435953596359735983599360036013602360336043605360636073608360936103611361236133614361536163617361836193620362136223623362436253626362736283629363036313632363336343635363636373638363936403641364236433644364536463647364836493650365136523653365436553656365736583659366036613662366336643665366636673668366936703671367236733674367536763677367836793680368136823683368436853686368736883689369036913692369336943695369636973698369937003701370237033704370537063707370837093710371137123713371437153716371737183719372037213722372337243725372637273728372937303731373237333734373537363737373837393740374137423743374437453746374737483749375037513752375337543755375637573758375937603761376237633764376537663767376837693770377137723773377437753776377737783779378037813782378337843785378637873788378937903791379237933794379537963797379837993800380138023803380438053806380738083809381038113812381338143815381638173818381938203821382238233824382538263827382838293830383138323833383438353836383738383839384038413842384338443845384638473848384938503851385238533854385538563857385838593860386138623863386438653866386738683869387038713872387338743875387638773878387938803881388238833884388538863887388838893890389138923893389438953896389738983899390039013902390339043905390639073908390939103911391239133914391539163917391839193920392139223923392439253926392739283929393039313932393339343935393639373938393939403941394239433944394539463947394839493950395139523953395439553956395739583959396039613962396339643965396639673968396939703971397239733974397539763977397839793980398139823983398439853986398739883989399039913992399339943995399639973998399940004001400240034004400540064007400840094010401140124013401440154016401740184019402040214022402340244025402640274028402940304031403240334034403540364037403840394040404140424043404440454046404740484049405040514052405340544055405640574058405940604061406240634064406540664067406840694070407140724073407440754076407740784079408040814082408340844085408640874088408940904091409240934094409540964097409840994100410141024103410441054106410741084109411041114112411341144115411641174118411941204121412241234124412541264127412841294130413141324133413441354136413741384139414041414142414341444145414641474148414941504151415241534154415541564157415841594160416141624163416441654166416741684169417041714172417341744175417641774178417941804181418241834184418541864187418841894190419141924193419441954196419741984199420042014202420342044205420642074208420942104211421242134214421542164217421842194220422142224223422442254226422742284229423042314232423342344235423642374238423942404241424242434244424542464247424842494250425142524253425442554256425742584259426042614262426342644265426642674268426942704271427242734274427542764277427842794280428142824283428442854286428742884289429042914292429342944295429642974298429943004301430243034304430543064307430843094310431143124313431443154316431743184319432043214322432343244325432643274328432943304331433243334334433543364337433843394340434143424343434443454346434743484349435043514352435343544355435643574358435943604361436243634364436543664367436843694370437143724373437443754376437743784379438043814382438343844385438643874388438943904391439243934394439543964397439843994400440144024403440444054406440744084409441044114412441344144415441644174418441944204421442244234424442544264427442844294430443144324433443444354436443744384439444044414442444344444445444644474448444944504451445244534454445544564457445844594460446144624463446444654466446744684469447044714472447344744475447644774478447944804481448244834484448544864487448844894490449144924493449444954496449744984499450045014502450345044505450645074508450945104511451245134514451545164517451845194520452145224523452445254526452745284529453045314532453345344535453645374538453945404541454245434544454545464547454845494550455145524553455445554556455745584559456045614562456345644565456645674568456945704571457245734574457545764577457845794580458145824583458445854586458745884589459045914592459345944595459645974598459946004601460246034604460546064607460846094610461146124613461446154616461746184619462046214622462346244625462646274628462946304631463246334634463546364637463846394640464146424643464446454646464746484649465046514652465346544655465646574658465946604661466246634664466546664667466846694670467146724673467446754676467746784679468046814682468346844685468646874688468946904691469246934694469546964697469846994700470147024703470447054706470747084709471047114712471347144715471647174718471947204721472247234724472547264727472847294730473147324733473447354736473747384739474047414742474347444745474647474748474947504751475247534754475547564757475847594760476147624763476447654766476747684769477047714772477347744775477647774778477947804781478247834784478547864787478847894790479147924793479447954796479747984799480048014802480348044805480648074808480948104811481248134814481548164817481848194820482148224823482448254826482748284829483048314832483348344835483648374838483948404841484248434844484548464847484848494850485148524853485448554856485748584859486048614862486348644865486648674868486948704871487248734874487548764877487848794880488148824883488448854886488748884889489048914892489348944895489648974898489949004901490249034904490549064907490849094910491149124913491449154916491749184919492049214922492349244925492649274928492949304931493249334934493549364937493849394940494149424943494449454946494749484949495049514952495349544955495649574958495949604961496249634964496549664967
  1. /*
  2. * Copyright (c) 2020-2023, Andreas Kling <kling@serenityos.org>
  3. * Copyright (c) 2020-2023, Linus Groh <linusg@serenityos.org>
  4. * Copyright (c) 2021-2022, David Tuin <davidot@serenityos.org>
  5. *
  6. * SPDX-License-Identifier: BSD-2-Clause
  7. */
  8. #include <AK/Demangle.h>
  9. #include <AK/HashMap.h>
  10. #include <AK/HashTable.h>
  11. #include <AK/QuickSort.h>
  12. #include <AK/ScopeGuard.h>
  13. #include <AK/StringBuilder.h>
  14. #include <AK/TemporaryChange.h>
  15. #include <LibCrypto/BigInt/SignedBigInteger.h>
  16. #include <LibJS/AST.h>
  17. #include <LibJS/Heap/MarkedVector.h>
  18. #include <LibJS/Interpreter.h>
  19. #include <LibJS/Runtime/AbstractOperations.h>
  20. #include <LibJS/Runtime/Accessor.h>
  21. #include <LibJS/Runtime/Array.h>
  22. #include <LibJS/Runtime/BigInt.h>
  23. #include <LibJS/Runtime/ECMAScriptFunctionObject.h>
  24. #include <LibJS/Runtime/Error.h>
  25. #include <LibJS/Runtime/FunctionEnvironment.h>
  26. #include <LibJS/Runtime/GlobalObject.h>
  27. #include <LibJS/Runtime/Iterator.h>
  28. #include <LibJS/Runtime/NativeFunction.h>
  29. #include <LibJS/Runtime/ObjectEnvironment.h>
  30. #include <LibJS/Runtime/PrimitiveString.h>
  31. #include <LibJS/Runtime/PromiseCapability.h>
  32. #include <LibJS/Runtime/PromiseConstructor.h>
  33. #include <LibJS/Runtime/Reference.h>
  34. #include <LibJS/Runtime/RegExpObject.h>
  35. #include <LibJS/Runtime/Shape.h>
  36. #include <typeinfo>
  37. namespace JS {
  38. class InterpreterNodeScope {
  39. AK_MAKE_NONCOPYABLE(InterpreterNodeScope);
  40. AK_MAKE_NONMOVABLE(InterpreterNodeScope);
  41. public:
  42. InterpreterNodeScope(Interpreter& interpreter, ASTNode const& node)
  43. : m_interpreter(interpreter)
  44. , m_chain_node { nullptr, node }
  45. {
  46. m_interpreter.vm().running_execution_context().current_node = &node;
  47. #pragma GCC diagnostic push
  48. #pragma GCC diagnostic ignored "-Wdangling-pointer"
  49. // The node pointer is popped from the interpreter in the destructor.
  50. m_interpreter.push_ast_node(m_chain_node);
  51. #pragma GCC diagnostic push
  52. }
  53. ~InterpreterNodeScope()
  54. {
  55. m_interpreter.pop_ast_node();
  56. }
  57. private:
  58. Interpreter& m_interpreter;
  59. ExecutingASTNodeChain m_chain_node;
  60. };
  61. ASTNode::ASTNode(SourceRange source_range)
  62. : m_start_offset(source_range.start.offset)
  63. , m_source_code(source_range.code)
  64. , m_end_offset(source_range.end.offset)
  65. {
  66. }
  67. SourceRange ASTNode::source_range() const
  68. {
  69. return m_source_code->range_from_offsets(m_start_offset, m_end_offset);
  70. }
  71. DeprecatedString ASTNode::class_name() const
  72. {
  73. // NOTE: We strip the "JS::" prefix.
  74. auto const* typename_ptr = typeid(*this).name();
  75. return demangle({ typename_ptr, strlen(typename_ptr) }).substring(4);
  76. }
  77. static void print_indent(int indent)
  78. {
  79. out("{}", DeprecatedString::repeated(' ', indent * 2));
  80. }
  81. static void update_function_name(Value value, DeprecatedFlyString const& name)
  82. {
  83. if (!value.is_function())
  84. return;
  85. auto& function = value.as_function();
  86. if (is<ECMAScriptFunctionObject>(function) && function.name().is_empty())
  87. static_cast<ECMAScriptFunctionObject&>(function).set_name(name);
  88. }
  89. static ThrowCompletionOr<DeprecatedString> get_function_property_name(PropertyKey key)
  90. {
  91. if (key.is_symbol())
  92. return DeprecatedString::formatted("[{}]", key.as_symbol()->description().value_or(String {}));
  93. return key.to_string();
  94. }
  95. // 14.2.2 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-block-runtime-semantics-evaluation
  96. // StatementList : StatementList StatementListItem
  97. Completion ScopeNode::evaluate_statements(Interpreter& interpreter) const
  98. {
  99. auto completion = normal_completion({});
  100. for (auto const& node : children()) {
  101. completion = node->execute(interpreter).update_empty(completion.value());
  102. if (completion.is_abrupt())
  103. break;
  104. }
  105. return completion;
  106. }
  107. // 14.13.4 Runtime Semantics: LabelledEvaluation, https://tc39.es/ecma262/#sec-runtime-semantics-labelledevaluation
  108. // BreakableStatement : IterationStatement
  109. static Completion labelled_evaluation(Interpreter& interpreter, IterationStatement const& statement, Vector<DeprecatedFlyString> const& label_set)
  110. {
  111. // 1. Let stmtResult be Completion(LoopEvaluation of IterationStatement with argument labelSet).
  112. auto result = statement.loop_evaluation(interpreter, label_set);
  113. // 2. If stmtResult.[[Type]] is break, then
  114. if (result.type() == Completion::Type::Break) {
  115. // a. If stmtResult.[[Target]] is empty, then
  116. if (!result.target().has_value()) {
  117. // i. If stmtResult.[[Value]] is empty, set stmtResult to NormalCompletion(undefined).
  118. // ii. Else, set stmtResult to NormalCompletion(stmtResult.[[Value]]).
  119. result = normal_completion(result.value().value_or(js_undefined()));
  120. }
  121. }
  122. // 3. Return ? stmtResult.
  123. return result;
  124. }
  125. // 14.13.4 Runtime Semantics: LabelledEvaluation, https://tc39.es/ecma262/#sec-runtime-semantics-labelledevaluation
  126. // BreakableStatement : SwitchStatement
  127. static Completion labelled_evaluation(Interpreter& interpreter, SwitchStatement const& statement, Vector<DeprecatedFlyString> const&)
  128. {
  129. // 1. Let stmtResult be the result of evaluating SwitchStatement.
  130. auto result = statement.execute_impl(interpreter);
  131. // 2. If stmtResult.[[Type]] is break, then
  132. if (result.type() == Completion::Type::Break) {
  133. // a. If stmtResult.[[Target]] is empty, then
  134. if (!result.target().has_value()) {
  135. // i. If stmtResult.[[Value]] is empty, set stmtResult to NormalCompletion(undefined).
  136. // ii. Else, set stmtResult to NormalCompletion(stmtResult.[[Value]]).
  137. result = normal_completion(result.value().value_or(js_undefined()));
  138. }
  139. }
  140. // 3. Return ? stmtResult.
  141. return result;
  142. }
  143. // 14.13.4 Runtime Semantics: LabelledEvaluation, https://tc39.es/ecma262/#sec-runtime-semantics-labelledevaluation
  144. // LabelledStatement : LabelIdentifier : LabelledItem
  145. static Completion labelled_evaluation(Interpreter& interpreter, LabelledStatement const& statement, Vector<DeprecatedFlyString> const& label_set)
  146. {
  147. auto const& labelled_item = *statement.labelled_item();
  148. // 1. Let label be the StringValue of LabelIdentifier.
  149. auto const& label = statement.label();
  150. // 2. Let newLabelSet be the list-concatenation of labelSet and « label ».
  151. // Optimization: Avoid vector copy if possible.
  152. Optional<Vector<DeprecatedFlyString>> new_label_set;
  153. if (is<IterationStatement>(labelled_item) || is<SwitchStatement>(labelled_item) || is<LabelledStatement>(labelled_item)) {
  154. new_label_set = label_set;
  155. new_label_set->append(label);
  156. }
  157. // 3. Let stmtResult be Completion(LabelledEvaluation of LabelledItem with argument newLabelSet).
  158. Completion result;
  159. if (is<IterationStatement>(labelled_item))
  160. result = labelled_evaluation(interpreter, static_cast<IterationStatement const&>(labelled_item), *new_label_set);
  161. else if (is<SwitchStatement>(labelled_item))
  162. result = labelled_evaluation(interpreter, static_cast<SwitchStatement const&>(labelled_item), *new_label_set);
  163. else if (is<LabelledStatement>(labelled_item))
  164. result = labelled_evaluation(interpreter, static_cast<LabelledStatement const&>(labelled_item), *new_label_set);
  165. else
  166. result = labelled_item.execute(interpreter);
  167. // 4. If stmtResult.[[Type]] is break and SameValue(stmtResult.[[Target]], label) is true, then
  168. if (result.type() == Completion::Type::Break && result.target() == label) {
  169. // a. Set stmtResult to NormalCompletion(stmtResult.[[Value]]).
  170. result = normal_completion(result.value());
  171. }
  172. // 5. Return ? stmtResult.
  173. return result;
  174. }
  175. // 14.13.3 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-labelled-statements-runtime-semantics-evaluation
  176. Completion LabelledStatement::execute(Interpreter& interpreter) const
  177. {
  178. InterpreterNodeScope node_scope { interpreter, *this };
  179. // 1. Return ? LabelledEvaluation of this LabelledStatement with argument « ».
  180. return labelled_evaluation(interpreter, *this, {});
  181. }
  182. void LabelledStatement::dump(int indent) const
  183. {
  184. ASTNode::dump(indent);
  185. print_indent(indent + 1);
  186. outln("(Label)");
  187. print_indent(indent + 2);
  188. outln("\"{}\"", m_label);
  189. print_indent(indent + 1);
  190. outln("(Labelled item)");
  191. m_labelled_item->dump(indent + 2);
  192. }
  193. // 10.2.1.3 Runtime Semantics: EvaluateBody, https://tc39.es/ecma262/#sec-runtime-semantics-evaluatebody
  194. Completion FunctionBody::execute(Interpreter& interpreter) const
  195. {
  196. InterpreterNodeScope node_scope { interpreter, *this };
  197. // Note: Scoping should have already been set up by whoever is calling this FunctionBody.
  198. // 1. Return ? EvaluateFunctionBody of FunctionBody with arguments functionObject and argumentsList.
  199. return evaluate_statements(interpreter);
  200. }
  201. // 14.2.2 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-block-runtime-semantics-evaluation
  202. Completion BlockStatement::execute(Interpreter& interpreter) const
  203. {
  204. InterpreterNodeScope node_scope { interpreter, *this };
  205. auto& vm = interpreter.vm();
  206. Environment* old_environment { nullptr };
  207. // Optimization: We only need a new lexical environment if there are any lexical declarations. :^)
  208. if (!has_lexical_declarations())
  209. return evaluate_statements(interpreter);
  210. old_environment = vm.running_execution_context().lexical_environment;
  211. auto block_environment = new_declarative_environment(*old_environment);
  212. block_declaration_instantiation(vm, block_environment);
  213. vm.running_execution_context().lexical_environment = block_environment;
  214. // 5. Let blockValue be the result of evaluating StatementList.
  215. auto block_value = evaluate_statements(interpreter);
  216. // 6. Set blockValue to DisposeResources(blockEnv, blockValue).
  217. block_value = dispose_resources(vm, block_environment, block_value);
  218. vm.running_execution_context().lexical_environment = old_environment;
  219. return block_value;
  220. }
  221. Completion Program::execute(Interpreter& interpreter) const
  222. {
  223. InterpreterNodeScope node_scope { interpreter, *this };
  224. return evaluate_statements(interpreter);
  225. }
  226. // 15.2.6 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-function-definitions-runtime-semantics-evaluation
  227. Completion FunctionDeclaration::execute(Interpreter& interpreter) const
  228. {
  229. InterpreterNodeScope node_scope { interpreter, *this };
  230. auto& vm = interpreter.vm();
  231. if (m_is_hoisted) {
  232. // Perform special annexB steps see step 3 of: https://tc39.es/ecma262/#sec-web-compat-functiondeclarationinstantiation
  233. // i. Let genv be the running execution context's VariableEnvironment.
  234. auto variable_environment = interpreter.vm().running_execution_context().variable_environment;
  235. // ii. Let benv be the running execution context's LexicalEnvironment.
  236. auto lexical_environment = interpreter.vm().running_execution_context().lexical_environment;
  237. // iii. Let fobj be ! benv.GetBindingValue(F, false).
  238. auto function_object = MUST(lexical_environment->get_binding_value(vm, name(), false));
  239. // iv. Perform ? genv.SetMutableBinding(F, fobj, false).
  240. TRY(variable_environment->set_mutable_binding(vm, name(), function_object, false));
  241. // v. Return unused.
  242. return Optional<Value> {};
  243. }
  244. // 1. Return unused.
  245. return Optional<Value> {};
  246. }
  247. // 15.2.6 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-function-definitions-runtime-semantics-evaluation
  248. Completion FunctionExpression::execute(Interpreter& interpreter) const
  249. {
  250. InterpreterNodeScope node_scope { interpreter, *this };
  251. // 1. Return InstantiateOrdinaryFunctionExpression of FunctionExpression.
  252. return instantiate_ordinary_function_expression(interpreter.vm(), name());
  253. }
  254. // 15.2.5 Runtime Semantics: InstantiateOrdinaryFunctionExpression, https://tc39.es/ecma262/#sec-runtime-semantics-instantiateordinaryfunctionexpression
  255. Value FunctionExpression::instantiate_ordinary_function_expression(VM& vm, DeprecatedFlyString given_name) const
  256. {
  257. auto& realm = *vm.current_realm();
  258. if (given_name.is_empty())
  259. given_name = "";
  260. auto has_own_name = !name().is_empty();
  261. auto const used_name = has_own_name ? name() : given_name.view();
  262. auto environment = NonnullGCPtr { *vm.running_execution_context().lexical_environment };
  263. if (has_own_name) {
  264. VERIFY(environment);
  265. environment = new_declarative_environment(*environment);
  266. MUST(environment->create_immutable_binding(vm, name(), false));
  267. }
  268. auto private_environment = vm.running_execution_context().private_environment;
  269. auto closure = ECMAScriptFunctionObject::create(realm, used_name, source_text(), body(), parameters(), function_length(), local_variables_names(), environment, private_environment, kind(), is_strict_mode(), might_need_arguments_object(), contains_direct_call_to_eval(), is_arrow_function());
  270. // FIXME: 6. Perform SetFunctionName(closure, name).
  271. // FIXME: 7. Perform MakeConstructor(closure).
  272. if (has_own_name)
  273. MUST(environment->initialize_binding(vm, name(), closure, Environment::InitializeBindingHint::Normal));
  274. return closure;
  275. }
  276. // 14.4.1 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-empty-statement-runtime-semantics-evaluation
  277. Completion EmptyStatement::execute(Interpreter&) const
  278. {
  279. // 1. Return empty.
  280. return Optional<Value> {};
  281. }
  282. // 14.5.1 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-expression-statement-runtime-semantics-evaluation
  283. Completion ExpressionStatement::execute(Interpreter& interpreter) const
  284. {
  285. InterpreterNodeScope node_scope { interpreter, *this };
  286. // 1. Let exprRef be the result of evaluating Expression.
  287. // 2. Return ? GetValue(exprRef).
  288. return m_expression->execute(interpreter);
  289. }
  290. // TODO: This shouldn't exist. Refactor into EvaluateCall.
  291. ThrowCompletionOr<CallExpression::ThisAndCallee> CallExpression::compute_this_and_callee(Interpreter& interpreter, Reference const& callee_reference) const
  292. {
  293. auto& vm = interpreter.vm();
  294. if (callee_reference.is_property_reference()) {
  295. auto this_value = callee_reference.get_this_value();
  296. auto callee = TRY(callee_reference.get_value(vm));
  297. return ThisAndCallee { this_value, callee };
  298. }
  299. Value this_value = js_undefined();
  300. if (callee_reference.is_environment_reference()) {
  301. if (Object* base_object = callee_reference.base_environment().with_base_object(); base_object != nullptr)
  302. this_value = base_object;
  303. }
  304. // [[Call]] will handle that in non-strict mode the this value becomes the global object
  305. return ThisAndCallee {
  306. this_value,
  307. callee_reference.is_unresolvable()
  308. ? TRY(m_callee->execute(interpreter)).release_value()
  309. : TRY(callee_reference.get_value(vm))
  310. };
  311. }
  312. // 13.3.8.1 Runtime Semantics: ArgumentListEvaluation, https://tc39.es/ecma262/#sec-runtime-semantics-argumentlistevaluation
  313. static ThrowCompletionOr<void> argument_list_evaluation(Interpreter& interpreter, ReadonlySpan<CallExpression::Argument> const arguments, MarkedVector<Value>& list)
  314. {
  315. auto& vm = interpreter.vm();
  316. list.ensure_capacity(arguments.size());
  317. for (auto& argument : arguments) {
  318. auto value = TRY(argument.value->execute(interpreter)).release_value();
  319. if (argument.is_spread) {
  320. TRY(get_iterator_values(vm, value, [&](Value iterator_value) -> Optional<Completion> {
  321. list.append(iterator_value);
  322. return {};
  323. }));
  324. } else {
  325. list.append(value);
  326. }
  327. }
  328. return {};
  329. }
  330. // 13.3.5.1 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-new-operator-runtime-semantics-evaluation
  331. // 13.3.5.1.1 EvaluateNew ( constructExpr, arguments ), https://tc39.es/ecma262/#sec-evaluatenew
  332. Completion NewExpression::execute(Interpreter& interpreter) const
  333. {
  334. InterpreterNodeScope node_scope { interpreter, *this };
  335. auto& vm = interpreter.vm();
  336. // 1. Let ref be the result of evaluating constructExpr.
  337. // 2. Let constructor be ? GetValue(ref).
  338. auto constructor = TRY(m_callee->execute(interpreter)).release_value();
  339. // 3. If arguments is empty, let argList be a new empty List.
  340. // 4. Else,
  341. // a. Let argList be ? ArgumentListEvaluation of arguments.
  342. MarkedVector<Value> arg_list(vm.heap());
  343. TRY(argument_list_evaluation(interpreter, arguments(), arg_list));
  344. // 5. If IsConstructor(constructor) is false, throw a TypeError exception.
  345. if (!constructor.is_constructor())
  346. return throw_type_error_for_callee(interpreter, constructor, "constructor"sv);
  347. // 6. Return ? Construct(constructor, argList).
  348. return Value { TRY(construct(vm, constructor.as_function(), move(arg_list))) };
  349. }
  350. Optional<DeprecatedString> CallExpression::expression_string() const
  351. {
  352. if (is<Identifier>(*m_callee))
  353. return static_cast<Identifier const&>(*m_callee).string();
  354. if (is<MemberExpression>(*m_callee))
  355. return static_cast<MemberExpression const&>(*m_callee).to_string_approximation();
  356. return {};
  357. }
  358. Completion CallExpression::throw_type_error_for_callee(Interpreter& interpreter, Value callee_value, StringView call_type) const
  359. {
  360. auto& vm = interpreter.vm();
  361. if (auto expression_string = this->expression_string(); expression_string.has_value())
  362. return vm.throw_completion<TypeError>(ErrorType::IsNotAEvaluatedFrom, TRY_OR_THROW_OOM(vm, callee_value.to_string_without_side_effects()), call_type, expression_string.release_value());
  363. return vm.throw_completion<TypeError>(ErrorType::IsNotA, TRY_OR_THROW_OOM(vm, callee_value.to_string_without_side_effects()), call_type);
  364. }
  365. // 13.3.6.1 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-function-calls-runtime-semantics-evaluation
  366. Completion CallExpression::execute(Interpreter& interpreter) const
  367. {
  368. InterpreterNodeScope node_scope { interpreter, *this };
  369. auto& vm = interpreter.vm();
  370. auto& realm = *vm.current_realm();
  371. auto callee_reference = TRY(m_callee->to_reference(interpreter));
  372. auto [this_value, callee] = TRY(compute_this_and_callee(interpreter, callee_reference));
  373. VERIFY(!callee.is_empty());
  374. MarkedVector<Value> arg_list(vm.heap());
  375. TRY(argument_list_evaluation(interpreter, arguments(), arg_list));
  376. if (!callee.is_function())
  377. return throw_type_error_for_callee(interpreter, callee, "function"sv);
  378. auto& function = callee.as_function();
  379. if (&function == realm.intrinsics().eval_function()
  380. && callee_reference.is_environment_reference()
  381. && callee_reference.name().is_string()
  382. && callee_reference.name().as_string() == vm.names.eval.as_string()) {
  383. auto script_value = arg_list.size() == 0 ? js_undefined() : arg_list[0];
  384. return perform_eval(vm, script_value, vm.in_strict_mode() ? CallerMode::Strict : CallerMode::NonStrict, EvalMode::Direct);
  385. }
  386. return call(vm, function, this_value, move(arg_list));
  387. }
  388. // 13.3.7.1 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-super-keyword-runtime-semantics-evaluation
  389. // SuperCall : super Arguments
  390. Completion SuperCall::execute(Interpreter& interpreter) const
  391. {
  392. InterpreterNodeScope node_scope { interpreter, *this };
  393. auto& vm = interpreter.vm();
  394. // 1. Let newTarget be GetNewTarget().
  395. auto new_target = vm.get_new_target();
  396. // 2. Assert: Type(newTarget) is Object.
  397. VERIFY(new_target.is_function());
  398. // 3. Let func be GetSuperConstructor().
  399. auto* func = get_super_constructor(interpreter.vm());
  400. // 4. Let argList be ? ArgumentListEvaluation of Arguments.
  401. MarkedVector<Value> arg_list(vm.heap());
  402. if (m_is_synthetic == IsPartOfSyntheticConstructor::Yes) {
  403. // NOTE: This is the case where we have a fake constructor(...args) { super(...args); } which
  404. // shouldn't call @@iterator of %Array.prototype%.
  405. VERIFY(m_arguments.size() == 1);
  406. VERIFY(m_arguments[0].is_spread);
  407. auto const& argument = m_arguments[0];
  408. auto value = MUST(argument.value->execute(interpreter)).release_value();
  409. VERIFY(value.is_object() && is<Array>(value.as_object()));
  410. auto& array_value = static_cast<Array const&>(value.as_object());
  411. auto length = MUST(length_of_array_like(vm, array_value));
  412. for (size_t i = 0; i < length; ++i)
  413. arg_list.append(array_value.get_without_side_effects(PropertyKey { i }));
  414. } else {
  415. TRY(argument_list_evaluation(interpreter, m_arguments, arg_list));
  416. }
  417. // 5. If IsConstructor(func) is false, throw a TypeError exception.
  418. if (!func || !Value(func).is_constructor())
  419. return vm.throw_completion<TypeError>(ErrorType::NotAConstructor, "Super constructor");
  420. // 6. Let result be ? Construct(func, argList, newTarget).
  421. auto result = TRY(construct(vm, static_cast<FunctionObject&>(*func), move(arg_list), &new_target.as_function()));
  422. // 7. Let thisER be GetThisEnvironment().
  423. auto& this_er = verify_cast<FunctionEnvironment>(*get_this_environment(vm));
  424. // 8. Perform ? thisER.BindThisValue(result).
  425. TRY(this_er.bind_this_value(vm, result));
  426. // 9. Let F be thisER.[[FunctionObject]].
  427. // 10. Assert: F is an ECMAScript function object.
  428. // NOTE: This is implied by the strong C++ type.
  429. [[maybe_unused]] auto& f = this_er.function_object();
  430. // 11. Perform ? InitializeInstanceElements(result, F).
  431. TRY(result->initialize_instance_elements(f));
  432. // 12. Return result.
  433. return Value { result };
  434. }
  435. // 15.5.5 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-generator-function-definitions-runtime-semantics-evaluation
  436. Completion YieldExpression::execute(Interpreter&) const
  437. {
  438. // This should be transformed to a return.
  439. VERIFY_NOT_REACHED();
  440. }
  441. // 15.8.5 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-async-function-definitions-runtime-semantics-evaluation
  442. Completion AwaitExpression::execute(Interpreter& interpreter) const
  443. {
  444. InterpreterNodeScope node_scope { interpreter, *this };
  445. auto& vm = interpreter.vm();
  446. // 1. Let exprRef be the result of evaluating UnaryExpression.
  447. // 2. Let value be ? GetValue(exprRef).
  448. auto value = TRY(m_argument->execute(interpreter)).release_value();
  449. // 3. Return ? Await(value).
  450. return await(vm, value);
  451. }
  452. // 14.10.1 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-return-statement-runtime-semantics-evaluation
  453. Completion ReturnStatement::execute(Interpreter& interpreter) const
  454. {
  455. InterpreterNodeScope node_scope { interpreter, *this };
  456. // ReturnStatement : return ;
  457. if (!m_argument) {
  458. // 1. Return Completion Record { [[Type]]: return, [[Value]]: undefined, [[Target]]: empty }.
  459. return { Completion::Type::Return, js_undefined(), {} };
  460. }
  461. // ReturnStatement : return Expression ;
  462. // 1. Let exprRef be the result of evaluating Expression.
  463. // 2. Let exprValue be ? GetValue(exprRef).
  464. auto value = TRY(m_argument->execute(interpreter));
  465. // NOTE: Generators are not supported in the AST interpreter
  466. // 3. If GetGeneratorKind() is async, set exprValue to ? Await(exprValue).
  467. // 4. Return Completion Record { [[Type]]: return, [[Value]]: exprValue, [[Target]]: empty }.
  468. return { Completion::Type::Return, value, {} };
  469. }
  470. // 14.6.2 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-if-statement-runtime-semantics-evaluation
  471. Completion IfStatement::execute(Interpreter& interpreter) const
  472. {
  473. InterpreterNodeScope node_scope { interpreter, *this };
  474. // IfStatement : if ( Expression ) Statement else Statement
  475. // 1. Let exprRef be the result of evaluating Expression.
  476. // 2. Let exprValue be ToBoolean(? GetValue(exprRef)).
  477. auto predicate_result = TRY(m_predicate->execute(interpreter)).release_value();
  478. // 3. If exprValue is true, then
  479. if (predicate_result.to_boolean()) {
  480. // a. Let stmtCompletion be the result of evaluating the first Statement.
  481. // 5. Return ? UpdateEmpty(stmtCompletion, undefined).
  482. return m_consequent->execute(interpreter).update_empty(js_undefined());
  483. }
  484. // 4. Else,
  485. if (m_alternate) {
  486. // a. Let stmtCompletion be the result of evaluating the second Statement.
  487. // 5. Return ? UpdateEmpty(stmtCompletion, undefined).
  488. return m_alternate->execute(interpreter).update_empty(js_undefined());
  489. }
  490. // IfStatement : if ( Expression ) Statement
  491. // 3. If exprValue is false, then
  492. // a. Return undefined.
  493. return js_undefined();
  494. }
  495. // 14.11.2 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-with-statement-runtime-semantics-evaluation
  496. // WithStatement : with ( Expression ) Statement
  497. Completion WithStatement::execute(Interpreter& interpreter) const
  498. {
  499. InterpreterNodeScope node_scope { interpreter, *this };
  500. auto& vm = interpreter.vm();
  501. // 1. Let value be the result of evaluating Expression.
  502. auto value = TRY(m_object->execute(interpreter)).release_value();
  503. // 2. Let obj be ? ToObject(? GetValue(value)).
  504. auto object = TRY(value.to_object(vm));
  505. // 3. Let oldEnv be the running execution context's LexicalEnvironment.
  506. auto old_environment = vm.running_execution_context().lexical_environment;
  507. // 4. Let newEnv be NewObjectEnvironment(obj, true, oldEnv).
  508. auto new_environment = new_object_environment(object, true, old_environment);
  509. // 5. Set the running execution context's LexicalEnvironment to newEnv.
  510. vm.running_execution_context().lexical_environment = new_environment;
  511. // 6. Let C be the result of evaluating Statement.
  512. auto result = m_body->execute(interpreter);
  513. // 7. Set the running execution context's LexicalEnvironment to oldEnv.
  514. vm.running_execution_context().lexical_environment = old_environment;
  515. // 8. Return ? UpdateEmpty(C, undefined).
  516. return result.update_empty(js_undefined());
  517. }
  518. // 14.7.1.1 LoopContinues ( completion, labelSet ), https://tc39.es/ecma262/#sec-loopcontinues
  519. static bool loop_continues(Completion const& completion, Vector<DeprecatedFlyString> const& label_set)
  520. {
  521. // 1. If completion.[[Type]] is normal, return true.
  522. if (completion.type() == Completion::Type::Normal)
  523. return true;
  524. // 2. If completion.[[Type]] is not continue, return false.
  525. if (completion.type() != Completion::Type::Continue)
  526. return false;
  527. // 3. If completion.[[Target]] is empty, return true.
  528. if (!completion.target().has_value())
  529. return true;
  530. // 4. If completion.[[Target]] is an element of labelSet, return true.
  531. if (label_set.contains_slow(*completion.target()))
  532. return true;
  533. // 5. Return false.
  534. return false;
  535. }
  536. // 14.1.1 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-statement-semantics-runtime-semantics-evaluation
  537. // BreakableStatement : IterationStatement
  538. Completion WhileStatement::execute(Interpreter& interpreter) const
  539. {
  540. // 1. Let newLabelSet be a new empty List.
  541. // 2. Return ? LabelledEvaluation of this BreakableStatement with argument newLabelSet.
  542. return labelled_evaluation(interpreter, *this, {});
  543. }
  544. // 14.7.3.2 Runtime Semantics: WhileLoopEvaluation, https://tc39.es/ecma262/#sec-runtime-semantics-whileloopevaluation
  545. Completion WhileStatement::loop_evaluation(Interpreter& interpreter, Vector<DeprecatedFlyString> const& label_set) const
  546. {
  547. InterpreterNodeScope node_scope { interpreter, *this };
  548. // 1. Let V be undefined.
  549. auto last_value = js_undefined();
  550. // 2. Repeat,
  551. for (;;) {
  552. // a. Let exprRef be the result of evaluating Expression.
  553. // b. Let exprValue be ? GetValue(exprRef).
  554. auto test_result = TRY(m_test->execute(interpreter)).release_value();
  555. // c. If ToBoolean(exprValue) is false, return V.
  556. if (!test_result.to_boolean())
  557. return last_value;
  558. // d. Let stmtResult be the result of evaluating Statement.
  559. auto body_result = m_body->execute(interpreter);
  560. // e. If LoopContinues(stmtResult, labelSet) is false, return ? UpdateEmpty(stmtResult, V).
  561. if (!loop_continues(body_result, label_set))
  562. return body_result.update_empty(last_value);
  563. // f. If stmtResult.[[Value]] is not empty, set V to stmtResult.[[Value]].
  564. if (body_result.value().has_value())
  565. last_value = *body_result.value();
  566. }
  567. VERIFY_NOT_REACHED();
  568. }
  569. // 14.1.1 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-statement-semantics-runtime-semantics-evaluation
  570. // BreakableStatement : IterationStatement
  571. Completion DoWhileStatement::execute(Interpreter& interpreter) const
  572. {
  573. // 1. Let newLabelSet be a new empty List.
  574. // 2. Return ? LabelledEvaluation of this BreakableStatement with argument newLabelSet.
  575. return labelled_evaluation(interpreter, *this, {});
  576. }
  577. // 14.7.2.2 Runtime Semantics: DoWhileLoopEvaluation, https://tc39.es/ecma262/#sec-runtime-semantics-dowhileloopevaluation
  578. Completion DoWhileStatement::loop_evaluation(Interpreter& interpreter, Vector<DeprecatedFlyString> const& label_set) const
  579. {
  580. InterpreterNodeScope node_scope { interpreter, *this };
  581. // 1. Let V be undefined.
  582. auto last_value = js_undefined();
  583. // 2. Repeat,
  584. for (;;) {
  585. // a. Let stmtResult be the result of evaluating Statement.
  586. auto body_result = m_body->execute(interpreter);
  587. // b. If LoopContinues(stmtResult, labelSet) is false, return ? UpdateEmpty(stmtResult, V).
  588. if (!loop_continues(body_result, label_set))
  589. return body_result.update_empty(last_value);
  590. // c. If stmtResult.[[Value]] is not empty, set V to stmtResult.[[Value]].
  591. if (body_result.value().has_value())
  592. last_value = *body_result.value();
  593. // d. Let exprRef be the result of evaluating Expression.
  594. // e. Let exprValue be ? GetValue(exprRef).
  595. auto test_result = TRY(m_test->execute(interpreter)).release_value();
  596. // f. If ToBoolean(exprValue) is false, return V.
  597. if (!test_result.to_boolean())
  598. return last_value;
  599. }
  600. VERIFY_NOT_REACHED();
  601. }
  602. // 14.1.1 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-statement-semantics-runtime-semantics-evaluation
  603. // BreakableStatement : IterationStatement
  604. Completion ForStatement::execute(Interpreter& interpreter) const
  605. {
  606. // 1. Let newLabelSet be a new empty List.
  607. // 2. Return ? LabelledEvaluation of this BreakableStatement with argument newLabelSet.
  608. return labelled_evaluation(interpreter, *this, {});
  609. }
  610. // 14.7.4.2 Runtime Semantics: ForLoopEvaluation, https://tc39.es/ecma262/#sec-runtime-semantics-forloopevaluation
  611. Completion ForStatement::loop_evaluation(Interpreter& interpreter, Vector<DeprecatedFlyString> const& label_set) const
  612. {
  613. InterpreterNodeScope node_scope { interpreter, *this };
  614. auto& vm = interpreter.vm();
  615. // Note we don't always set a new environment but to use RAII we must do this here.
  616. auto* old_environment = interpreter.lexical_environment();
  617. size_t per_iteration_bindings_size = 0;
  618. GCPtr<DeclarativeEnvironment> loop_env;
  619. if (m_init) {
  620. Declaration const* declaration = nullptr;
  621. if (is<VariableDeclaration>(*m_init) && static_cast<VariableDeclaration const&>(*m_init).declaration_kind() != DeclarationKind::Var)
  622. declaration = static_cast<VariableDeclaration const*>(m_init.ptr());
  623. else if (is<UsingDeclaration>(*m_init))
  624. declaration = static_cast<UsingDeclaration const*>(m_init.ptr());
  625. if (declaration) {
  626. loop_env = new_declarative_environment(*old_environment);
  627. auto is_const = declaration->is_constant_declaration();
  628. // NOTE: Due to the use of MUST with `create_immutable_binding` and `create_mutable_binding` below,
  629. // an exception should not result from `for_each_bound_identifier`.
  630. MUST(declaration->for_each_bound_identifier([&](auto const& identifier) {
  631. auto const& name = identifier.string();
  632. if (is_const) {
  633. MUST(loop_env->create_immutable_binding(vm, name, true));
  634. } else {
  635. MUST(loop_env->create_mutable_binding(vm, name, false));
  636. ++per_iteration_bindings_size;
  637. }
  638. }));
  639. interpreter.vm().running_execution_context().lexical_environment = loop_env;
  640. }
  641. (void)TRY(m_init->execute(interpreter));
  642. }
  643. // 10. Let bodyResult be Completion(ForBodyEvaluation(the first Expression, the second Expression, Statement, perIterationLets, labelSet)).
  644. auto body_result = for_body_evaluation(interpreter, label_set, per_iteration_bindings_size);
  645. // 11. Set bodyResult to DisposeResources(loopEnv, bodyResult).
  646. if (loop_env)
  647. body_result = dispose_resources(vm, loop_env.ptr(), body_result);
  648. // 12. Set the running execution context's LexicalEnvironment to oldEnv.
  649. interpreter.vm().running_execution_context().lexical_environment = old_environment;
  650. // 13. Return ? bodyResult.
  651. return body_result;
  652. }
  653. // 14.7.4.3 ForBodyEvaluation ( test, increment, stmt, perIterationBindings, labelSet ), https://tc39.es/ecma262/#sec-forbodyevaluation
  654. // 6.3.1.2 ForBodyEvaluation ( test, increment, stmt, perIterationBindings, labelSet ), https://tc39.es/proposal-explicit-resource-management/#sec-forbodyevaluation
  655. Completion ForStatement::for_body_evaluation(JS::Interpreter& interpreter, Vector<DeprecatedFlyString> const& label_set, size_t per_iteration_bindings_size) const
  656. {
  657. auto& vm = interpreter.vm();
  658. // 14.7.4.4 CreatePerIterationEnvironment ( perIterationBindings ), https://tc39.es/ecma262/#sec-createperiterationenvironment
  659. // NOTE: Our implementation of this AO is heavily dependent on DeclarativeEnvironment using a Vector with constant indices.
  660. // For performance, we can take advantage of the fact that the declarations of the initialization statement are created
  661. // in the same order each time CreatePerIterationEnvironment is invoked.
  662. auto create_per_iteration_environment = [&]() -> GCPtr<DeclarativeEnvironment> {
  663. // 1. If perIterationBindings has any elements, then
  664. if (per_iteration_bindings_size == 0) {
  665. // 2. Return unused.
  666. return nullptr;
  667. }
  668. // a. Let lastIterationEnv be the running execution context's LexicalEnvironment.
  669. auto* last_iteration_env = verify_cast<DeclarativeEnvironment>(interpreter.lexical_environment());
  670. // b. Let outer be lastIterationEnv.[[OuterEnv]].
  671. // c. Assert: outer is not null.
  672. VERIFY(last_iteration_env->outer_environment());
  673. // d. Let thisIterationEnv be NewDeclarativeEnvironment(outer).
  674. auto this_iteration_env = DeclarativeEnvironment::create_for_per_iteration_bindings({}, *last_iteration_env, per_iteration_bindings_size);
  675. // e. For each element bn of perIterationBindings, do
  676. // i. Perform ! thisIterationEnv.CreateMutableBinding(bn, false).
  677. // ii. Let lastValue be ? lastIterationEnv.GetBindingValue(bn, true).
  678. // iii. Perform ! thisIterationEnv.InitializeBinding(bn, lastValue).
  679. //
  680. // NOTE: This is handled by DeclarativeEnvironment::create_for_per_iteration_bindings. Step e.ii indicates it may throw,
  681. // but that is not possible. The potential for throwing was added to accommodate support for do-expressions in the
  682. // initialization statement, but that idea was dropped: https://github.com/tc39/ecma262/issues/299#issuecomment-172950045
  683. // f. Set the running execution context's LexicalEnvironment to thisIterationEnv.
  684. interpreter.vm().running_execution_context().lexical_environment = this_iteration_env;
  685. // g. Return thisIterationEnv.
  686. return this_iteration_env;
  687. };
  688. // 1. Let V be undefined.
  689. auto last_value = js_undefined();
  690. // 2. Let thisIterationEnv be ? CreatePerIterationEnvironment(perIterationBindings).
  691. auto this_iteration_env = create_per_iteration_environment();
  692. // 3. Repeat,
  693. while (true) {
  694. // a. If test is not [empty], then
  695. if (m_test) {
  696. // i. Let testRef be the result of evaluating test.
  697. // ii. Let testValue be Completion(GetValue(testRef)).
  698. auto test_value = m_test->execute(interpreter);
  699. // iii. If testValue is an abrupt completion, then
  700. if (test_value.is_abrupt()) {
  701. // 1. Return ? DisposeResources(thisIterationEnv, testValue).
  702. return TRY(dispose_resources(vm, this_iteration_env, test_value));
  703. }
  704. // iv. Else,
  705. // 1. Set testValue to testValue.[[Value]].
  706. VERIFY(test_value.value().has_value());
  707. // iii. If ToBoolean(testValue) is false, return ? DisposeResources(thisIterationEnv, Completion(V)).
  708. if (!test_value.release_value().value().to_boolean())
  709. return TRY(dispose_resources(vm, this_iteration_env, test_value));
  710. }
  711. // b. Let result be the result of evaluating stmt.
  712. auto result = m_body->execute(interpreter);
  713. // c. Perform ? DisposeResources(thisIterationEnv, result).
  714. TRY(dispose_resources(vm, this_iteration_env, result));
  715. // d. If LoopContinues(result, labelSet) is false, return ? UpdateEmpty(result, V).
  716. if (!loop_continues(result, label_set))
  717. return result.update_empty(last_value);
  718. // e. If result.[[Value]] is not empty, set V to result.[[Value]].
  719. if (result.value().has_value())
  720. last_value = *result.value();
  721. // f. Set thisIterationEnv to ? CreatePerIterationEnvironment(perIterationBindings).
  722. this_iteration_env = create_per_iteration_environment();
  723. // g. If increment is not [empty], then
  724. if (m_update) {
  725. // i. Let incRef be the result of evaluating increment.
  726. // ii. Let incrResult be Completion(GetValue(incrRef)).
  727. auto inc_ref = m_update->execute(interpreter);
  728. // ii. If incrResult is an abrupt completion, then
  729. if (inc_ref.is_abrupt()) {
  730. // 1. Return ? DisposeResources(thisIterationEnv, incrResult).
  731. return TRY(dispose_resources(vm, this_iteration_env, inc_ref));
  732. }
  733. }
  734. }
  735. VERIFY_NOT_REACHED();
  736. }
  737. struct ForInOfHeadState {
  738. explicit ForInOfHeadState(Variant<NonnullRefPtr<ASTNode const>, NonnullRefPtr<BindingPattern const>> lhs)
  739. {
  740. lhs.visit(
  741. [&](NonnullRefPtr<ASTNode const>& ast_node) {
  742. expression_lhs = ast_node.ptr();
  743. },
  744. [&](NonnullRefPtr<BindingPattern const>& pattern) {
  745. pattern_lhs = pattern.ptr();
  746. destructuring = true;
  747. lhs_kind = Assignment;
  748. });
  749. }
  750. ASTNode const* expression_lhs = nullptr;
  751. BindingPattern const* pattern_lhs = nullptr;
  752. enum LhsKind {
  753. Assignment,
  754. VarBinding,
  755. LexicalBinding
  756. };
  757. LhsKind lhs_kind = Assignment;
  758. bool destructuring = false;
  759. Value rhs_value;
  760. // 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
  761. // Note: This is only steps 6.g through 6.j of the method because we currently implement for-in without an iterator so to prevent duplicated code we do this part here.
  762. ThrowCompletionOr<void> execute_head(Interpreter& interpreter, Value next_value) const
  763. {
  764. VERIFY(!next_value.is_empty());
  765. auto& vm = interpreter.vm();
  766. Optional<Reference> lhs_reference;
  767. GCPtr<Environment> iteration_environment;
  768. // g. If lhsKind is either assignment or varBinding, then
  769. if (lhs_kind == Assignment || lhs_kind == VarBinding) {
  770. if (!destructuring) {
  771. VERIFY(expression_lhs);
  772. if (is<VariableDeclaration>(*expression_lhs)) {
  773. auto& declaration = static_cast<VariableDeclaration const&>(*expression_lhs);
  774. VERIFY(declaration.declarations().first()->target().has<NonnullRefPtr<Identifier const>>());
  775. lhs_reference = TRY(declaration.declarations().first()->target().get<NonnullRefPtr<Identifier const>>()->to_reference(interpreter));
  776. } else if (is<UsingDeclaration>(*expression_lhs)) {
  777. auto& declaration = static_cast<UsingDeclaration const&>(*expression_lhs);
  778. VERIFY(declaration.declarations().first()->target().has<NonnullRefPtr<Identifier const>>());
  779. lhs_reference = TRY(declaration.declarations().first()->target().get<NonnullRefPtr<Identifier const>>()->to_reference(interpreter));
  780. } else {
  781. VERIFY(is<Identifier>(*expression_lhs) || is<MemberExpression>(*expression_lhs) || is<CallExpression>(*expression_lhs));
  782. auto& expression = static_cast<Expression const&>(*expression_lhs);
  783. lhs_reference = TRY(expression.to_reference(interpreter));
  784. }
  785. }
  786. }
  787. // h. Else,
  788. else {
  789. VERIFY(expression_lhs && (is<VariableDeclaration>(*expression_lhs) || is<UsingDeclaration>(*expression_lhs)));
  790. iteration_environment = new_declarative_environment(*interpreter.lexical_environment());
  791. auto& for_declaration = static_cast<Declaration const&>(*expression_lhs);
  792. DeprecatedFlyString first_name;
  793. // 14.7.5.4 Runtime Semantics: ForDeclarationBindingInstantiation, https://tc39.es/ecma262/#sec-runtime-semantics-fordeclarationbindinginstantiation
  794. // 1. For each element name of the BoundNames of ForBinding, do
  795. // NOTE: Due to the use of MUST with `create_immutable_binding` and `create_mutable_binding` below,
  796. // an exception should not result from `for_each_bound_identifier`.
  797. MUST(for_declaration.for_each_bound_identifier([&](auto const& identifier) {
  798. auto const& name = identifier.string();
  799. if (first_name.is_empty())
  800. first_name = name;
  801. // a. If IsConstantDeclaration of LetOrConst is true, then
  802. if (for_declaration.is_constant_declaration()) {
  803. // i. Perform ! environment.CreateImmutableBinding(name, true).
  804. MUST(iteration_environment->create_immutable_binding(vm, name, true));
  805. }
  806. // b. Else,
  807. else {
  808. // i. Perform ! environment.CreateMutableBinding(name, false).
  809. MUST(iteration_environment->create_mutable_binding(vm, name, false));
  810. }
  811. }));
  812. interpreter.vm().running_execution_context().lexical_environment = iteration_environment;
  813. if (!destructuring) {
  814. VERIFY(!first_name.is_empty());
  815. lhs_reference = MUST(interpreter.vm().resolve_binding(first_name));
  816. }
  817. }
  818. // i. If destructuring is false, then
  819. if (!destructuring) {
  820. VERIFY(lhs_reference.has_value());
  821. if (lhs_kind == LexicalBinding) {
  822. // 2. If IsUsingDeclaration of lhs is true, then
  823. if (is<UsingDeclaration>(expression_lhs)) {
  824. // a. Let status be Completion(InitializeReferencedBinding(lhsRef, nextValue, sync-dispose)).
  825. return lhs_reference->initialize_referenced_binding(vm, next_value, Environment::InitializeBindingHint::SyncDispose);
  826. }
  827. // 3. Else,
  828. else {
  829. // a. Let status be Completion(InitializeReferencedBinding(lhsRef, nextValue, normal)).
  830. return lhs_reference->initialize_referenced_binding(vm, next_value, Environment::InitializeBindingHint::Normal);
  831. }
  832. } else {
  833. return lhs_reference->put_value(vm, next_value);
  834. }
  835. }
  836. // j. Else,
  837. if (lhs_kind == Assignment) {
  838. VERIFY(pattern_lhs);
  839. return interpreter.vm().destructuring_assignment_evaluation(*pattern_lhs, next_value);
  840. }
  841. VERIFY(expression_lhs && is<VariableDeclaration>(*expression_lhs));
  842. auto& for_declaration = static_cast<VariableDeclaration const&>(*expression_lhs);
  843. auto& binding_pattern = for_declaration.declarations().first()->target().get<NonnullRefPtr<BindingPattern const>>();
  844. VERIFY(lhs_kind == VarBinding || iteration_environment);
  845. // At this point iteration_environment is undefined if lhs_kind == VarBinding which means this does both
  846. // branch j.ii and j.iii because ForBindingInitialization is just a forwarding call to BindingInitialization.
  847. return interpreter.vm().binding_initialization(binding_pattern, next_value, iteration_environment);
  848. }
  849. };
  850. // 14.7.5.5 Runtime Semantics: ForInOfLoopEvaluation, https://tc39.es/ecma262/#sec-runtime-semantics-forinofloopevaluation
  851. // 14.7.5.6 ForIn/OfHeadEvaluation ( uninitializedBoundNames, expr, iterationKind ), https://tc39.es/ecma262/#sec-runtime-semantics-forinofheadevaluation
  852. // This method combines ForInOfLoopEvaluation and ForIn/OfHeadEvaluation for similar reason as ForIn/OfBodyEvaluation, to prevent code duplication.
  853. // For the same reason we also skip step 6 and 7 of ForIn/OfHeadEvaluation as this is done by the appropriate for loop type.
  854. static ThrowCompletionOr<ForInOfHeadState> for_in_of_head_execute(Interpreter& interpreter, Variant<NonnullRefPtr<ASTNode const>, NonnullRefPtr<BindingPattern const>> lhs, Expression const& rhs)
  855. {
  856. auto& vm = interpreter.vm();
  857. ForInOfHeadState state(lhs);
  858. if (auto* ast_ptr = lhs.get_pointer<NonnullRefPtr<ASTNode const>>(); ast_ptr && is<Declaration>(ast_ptr->ptr())) {
  859. // Runtime Semantics: ForInOfLoopEvaluation, for any of:
  860. // ForInOfStatement : for ( var ForBinding in Expression ) Statement
  861. // ForInOfStatement : for ( ForDeclaration in Expression ) Statement
  862. // ForInOfStatement : for ( var ForBinding of AssignmentExpression ) Statement
  863. // ForInOfStatement : for ( ForDeclaration of AssignmentExpression ) Statement
  864. // 14.7.5.6 ForIn/OfHeadEvaluation ( uninitializedBoundNames, expr, iterationKind ), https://tc39.es/ecma262/#sec-runtime-semantics-forinofheadevaluation
  865. Environment* new_environment = nullptr;
  866. if (is<VariableDeclaration>(ast_ptr->ptr())) {
  867. auto& variable_declaration = static_cast<VariableDeclaration const&>(*(*ast_ptr));
  868. VERIFY(variable_declaration.declarations().size() == 1);
  869. state.destructuring = variable_declaration.declarations().first()->target().has<NonnullRefPtr<BindingPattern const>>();
  870. if (variable_declaration.declaration_kind() == DeclarationKind::Var) {
  871. state.lhs_kind = ForInOfHeadState::VarBinding;
  872. auto& variable = variable_declaration.declarations().first();
  873. // B.3.5 Initializers in ForIn Statement Heads, https://tc39.es/ecma262/#sec-initializers-in-forin-statement-heads
  874. if (variable->init()) {
  875. VERIFY(variable->target().has<NonnullRefPtr<Identifier const>>());
  876. auto& binding_id = variable->target().get<NonnullRefPtr<Identifier const>>()->string();
  877. auto reference = TRY(interpreter.vm().resolve_binding(binding_id));
  878. auto result = TRY(interpreter.vm().named_evaluation_if_anonymous_function(*variable->init(), binding_id));
  879. TRY(reference.put_value(vm, result));
  880. }
  881. } else {
  882. state.lhs_kind = ForInOfHeadState::LexicalBinding;
  883. new_environment = new_declarative_environment(*interpreter.lexical_environment());
  884. // NOTE: Due to the use of MUST with `create_mutable_binding` below, an exception should not result from `for_each_bound_identifier.
  885. MUST(variable_declaration.for_each_bound_identifier([&](auto const& identifier) {
  886. MUST(new_environment->create_mutable_binding(vm, identifier.string(), false));
  887. }));
  888. }
  889. } else {
  890. VERIFY(is<UsingDeclaration>(ast_ptr->ptr()));
  891. auto& declaration = static_cast<UsingDeclaration const&>(*(*ast_ptr));
  892. state.lhs_kind = ForInOfHeadState::LexicalBinding;
  893. new_environment = new_declarative_environment(*interpreter.lexical_environment());
  894. // NOTE: Due to the use of MUST with `create_mutable_binding` below, an exception should not result from `for_each_bound_identifier.
  895. MUST(declaration.for_each_bound_identifier([&](auto const& identifier) {
  896. MUST(new_environment->create_mutable_binding(vm, identifier.string(), false));
  897. }));
  898. }
  899. if (new_environment) {
  900. // 2.d Set the running execution context's LexicalEnvironment to newEnv.
  901. TemporaryChange<GCPtr<Environment>> scope_change(interpreter.vm().running_execution_context().lexical_environment, new_environment);
  902. // 3. Let exprRef be the result of evaluating expr.
  903. // 5. Let exprValue be ? GetValue(exprRef).
  904. state.rhs_value = TRY(rhs.execute(interpreter)).release_value();
  905. // Note that since a reference stores its environment it doesn't matter we only reset
  906. // this after step 5. (Also we have no way of separating these steps at this point)
  907. // 4. Set the running execution context's LexicalEnvironment to oldEnv.
  908. } else {
  909. // 3. Let exprRef be the result of evaluating expr.
  910. // 5. Let exprValue be ? GetValue(exprRef).
  911. state.rhs_value = TRY(rhs.execute(interpreter)).release_value();
  912. }
  913. return state;
  914. }
  915. // Runtime Semantics: ForInOfLoopEvaluation, for any of:
  916. // ForInOfStatement : for ( LeftHandSideExpression in Expression ) Statement
  917. // ForInOfStatement : for ( LeftHandSideExpression of AssignmentExpression ) Statement
  918. // 14.7.5.6 ForIn/OfHeadEvaluation ( uninitializedBoundNames, expr, iterationKind ), https://tc39.es/ecma262/#sec-runtime-semantics-forinofheadevaluation
  919. // We can skip step 1, 2 and 4 here (on top of already skipping step 6 and 7).
  920. // 3. Let exprRef be the result of evaluating expr.
  921. // 5. Let exprValue be ? GetValue(exprRef).
  922. state.rhs_value = TRY(rhs.execute(interpreter)).release_value();
  923. return state;
  924. }
  925. // 14.1.1 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-statement-semantics-runtime-semantics-evaluation
  926. // BreakableStatement : IterationStatement
  927. Completion ForInStatement::execute(Interpreter& interpreter) const
  928. {
  929. // 1. Let newLabelSet be a new empty List.
  930. // 2. Return ? LabelledEvaluation of this BreakableStatement with argument newLabelSet.
  931. return labelled_evaluation(interpreter, *this, {});
  932. }
  933. // 14.7.5.5 Runtime Semantics: ForInOfLoopEvaluation, https://tc39.es/ecma262/#sec-runtime-semantics-forinofloopevaluation
  934. Completion ForInStatement::loop_evaluation(Interpreter& interpreter, Vector<DeprecatedFlyString> const& label_set) const
  935. {
  936. InterpreterNodeScope node_scope { interpreter, *this };
  937. auto& vm = interpreter.vm();
  938. auto for_in_head_state = TRY(for_in_of_head_execute(interpreter, m_lhs, *m_rhs));
  939. auto rhs_result = for_in_head_state.rhs_value;
  940. // 14.7.5.6 ForIn/OfHeadEvaluation ( uninitializedBoundNames, expr, iterationKind ), https://tc39.es/ecma262/#sec-runtime-semantics-forinofheadevaluation
  941. // a. If exprValue is undefined or null, then
  942. if (rhs_result.is_nullish()) {
  943. // i. Return Completion Record { [[Type]]: break, [[Value]]: empty, [[Target]]: empty }.
  944. return { Completion::Type::Break, {}, {} };
  945. }
  946. // b. Let obj be ! ToObject(exprValue).
  947. auto object = MUST(rhs_result.to_object(vm));
  948. // 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
  949. // 2. Let oldEnv be the running execution context's LexicalEnvironment.
  950. Environment* old_environment = interpreter.lexical_environment();
  951. auto restore_scope = ScopeGuard([&] {
  952. vm.running_execution_context().lexical_environment = old_environment;
  953. });
  954. // 3. Let V be undefined.
  955. auto last_value = js_undefined();
  956. auto result = object->enumerate_object_properties([&](auto value) -> Optional<Completion> {
  957. TRY(for_in_head_state.execute_head(interpreter, value));
  958. // l. Let result be the result of evaluating stmt.
  959. auto result = m_body->execute(interpreter);
  960. // NOTE: Because of optimizations we only create a new lexical environment if there are bindings
  961. // so we should only dispose if that is the case.
  962. if (vm.running_execution_context().lexical_environment != old_environment) {
  963. VERIFY(is<DeclarativeEnvironment>(*vm.running_execution_context().lexical_environment));
  964. // m. Set result to DisposeResources(iterationEnv, result).
  965. result = dispose_resources(vm, static_cast<DeclarativeEnvironment*>(vm.running_execution_context().lexical_environment.ptr()), result);
  966. }
  967. // n. Set the running execution context's LexicalEnvironment to oldEnv.
  968. vm.running_execution_context().lexical_environment = old_environment;
  969. // o. If LoopContinues(result, labelSet) is false, then
  970. if (!loop_continues(result, label_set)) {
  971. // 1. Return UpdateEmpty(result, V).
  972. return result.update_empty(last_value);
  973. }
  974. // p. If result.[[Value]] is not empty, set V to result.[[Value]].
  975. if (result.value().has_value())
  976. last_value = *result.value();
  977. return {};
  978. });
  979. return result.value_or(last_value);
  980. }
  981. // 14.1.1 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-statement-semantics-runtime-semantics-evaluation
  982. // BreakableStatement : IterationStatement
  983. Completion ForOfStatement::execute(Interpreter& interpreter) const
  984. {
  985. // 1. Let newLabelSet be a new empty List.
  986. // 2. Return ? LabelledEvaluation of this BreakableStatement with argument newLabelSet.
  987. return labelled_evaluation(interpreter, *this, {});
  988. }
  989. // 14.7.5.5 Runtime Semantics: ForInOfLoopEvaluation, https://tc39.es/ecma262/#sec-runtime-semantics-forinofloopevaluation
  990. Completion ForOfStatement::loop_evaluation(Interpreter& interpreter, Vector<DeprecatedFlyString> const& label_set) const
  991. {
  992. InterpreterNodeScope node_scope { interpreter, *this };
  993. auto& vm = interpreter.vm();
  994. auto for_of_head_state = TRY(for_in_of_head_execute(interpreter, m_lhs, m_rhs));
  995. auto rhs_result = for_of_head_state.rhs_value;
  996. // 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
  997. // We use get_iterator_values which behaves like ForIn/OfBodyEvaluation with iteratorKind iterate.
  998. // 2. Let oldEnv be the running execution context's LexicalEnvironment.
  999. Environment* old_environment = interpreter.lexical_environment();
  1000. auto restore_scope = ScopeGuard([&] {
  1001. vm.running_execution_context().lexical_environment = old_environment;
  1002. });
  1003. // 3. Let V be undefined.
  1004. auto last_value = js_undefined();
  1005. Optional<Completion> status;
  1006. (void)TRY(get_iterator_values(vm, rhs_result, [&](Value value) -> Optional<Completion> {
  1007. TRY(for_of_head_state.execute_head(interpreter, value));
  1008. // l. Let result be the result of evaluating stmt.
  1009. auto result = m_body->execute(interpreter);
  1010. if (vm.running_execution_context().lexical_environment != old_environment) {
  1011. VERIFY(is<DeclarativeEnvironment>(*vm.running_execution_context().lexical_environment));
  1012. result = dispose_resources(vm, static_cast<DeclarativeEnvironment*>(vm.running_execution_context().lexical_environment.ptr()), result);
  1013. }
  1014. // m. Set the running execution context's LexicalEnvironment to oldEnv.
  1015. vm.running_execution_context().lexical_environment = old_environment;
  1016. // n. If LoopContinues(result, labelSet) is false, then
  1017. if (!loop_continues(result, label_set)) {
  1018. // 2. Set status to UpdateEmpty(result, V).
  1019. status = result.update_empty(last_value);
  1020. // 4. Return ? IteratorClose(iteratorRecord, status).
  1021. // NOTE: This is done by returning a completion from the callback.
  1022. return status;
  1023. }
  1024. // o. If result.[[Value]] is not empty, set V to result.[[Value]].
  1025. if (result.value().has_value())
  1026. last_value = *result.value();
  1027. return {};
  1028. }));
  1029. // Return `status` set during step n.2. in the callback, or...
  1030. // e. If done is true, return V.
  1031. return status.value_or(last_value);
  1032. }
  1033. // 14.1.1 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-statement-semantics-runtime-semantics-evaluation
  1034. // BreakableStatement : IterationStatement
  1035. Completion ForAwaitOfStatement::execute(Interpreter& interpreter) const
  1036. {
  1037. // 1. Let newLabelSet be a new empty List.
  1038. // 2. Return ? LabelledEvaluation of this BreakableStatement with argument newLabelSet.
  1039. return labelled_evaluation(interpreter, *this, {});
  1040. }
  1041. // 14.7.5.5 Runtime Semantics: ForInOfLoopEvaluation, https://tc39.es/ecma262/#sec-runtime-semantics-forinofloopevaluation
  1042. Completion ForAwaitOfStatement::loop_evaluation(Interpreter& interpreter, Vector<DeprecatedFlyString> const& label_set) const
  1043. {
  1044. InterpreterNodeScope node_scope { interpreter, *this };
  1045. auto& vm = interpreter.vm();
  1046. // 14.7.5.6 ForIn/OfHeadEvaluation ( uninitializedBoundNames, expr, iterationKind ), https://tc39.es/ecma262/#sec-runtime-semantics-forinofheadevaluation
  1047. // Note: Performs only steps 1 through 5.
  1048. auto for_of_head_state = TRY(for_in_of_head_execute(interpreter, m_lhs, m_rhs));
  1049. auto rhs_result = for_of_head_state.rhs_value;
  1050. // NOTE: Perform step 7 from ForIn/OfHeadEvaluation. And since this is always async we only have to do step 7.d.
  1051. // d. Return ? GetIterator(exprValue, iteratorKind).
  1052. auto iterator = TRY(get_iterator(vm, rhs_result, IteratorHint::Async));
  1053. // 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
  1054. // NOTE: Here iteratorKind is always async.
  1055. // 2. Let oldEnv be the running execution context's LexicalEnvironment.
  1056. Environment* old_environment = interpreter.lexical_environment();
  1057. auto restore_scope = ScopeGuard([&] {
  1058. vm.running_execution_context().lexical_environment = old_environment;
  1059. });
  1060. // 3. Let V be undefined.
  1061. auto last_value = js_undefined();
  1062. // NOTE: Step 4 and 5 are just extracting properties from the head which is done already in for_in_of_head_execute.
  1063. // And these are only used in step 6.g through 6.k which is done with for_of_head_state.execute_head.
  1064. // 6. Repeat,
  1065. while (true) {
  1066. // a. Let nextResult be ? Call(iteratorRecord.[[NextMethod]], iteratorRecord.[[Iterator]]).
  1067. auto next_result = TRY(call(vm, iterator.next_method, iterator.iterator));
  1068. // b. If iteratorKind is async, set nextResult to ? Await(nextResult).
  1069. next_result = TRY(await(vm, next_result));
  1070. // c. If Type(nextResult) is not Object, throw a TypeError exception.
  1071. if (!next_result.is_object())
  1072. return vm.throw_completion<TypeError>(ErrorType::IterableNextBadReturn);
  1073. // d. Let done be ? IteratorComplete(nextResult).
  1074. auto done = TRY(iterator_complete(vm, next_result.as_object()));
  1075. // e. If done is true, return V.
  1076. if (done)
  1077. return last_value;
  1078. // f. Let nextValue be ? IteratorValue(nextResult).
  1079. auto next_value = TRY(iterator_value(vm, next_result.as_object()));
  1080. // NOTE: This performs steps g. through to k.
  1081. TRY(for_of_head_state.execute_head(interpreter, next_value));
  1082. // l. Let result be the result of evaluating stmt.
  1083. auto result = m_body->execute(interpreter);
  1084. // m. Set the running execution context's LexicalEnvironment to oldEnv.
  1085. interpreter.vm().running_execution_context().lexical_environment = old_environment;
  1086. // n. If LoopContinues(result, labelSet) is false, then
  1087. if (!loop_continues(result, label_set)) {
  1088. // 2. Set status to UpdateEmpty(result, V).
  1089. auto status = result.update_empty(last_value);
  1090. // 3. If iteratorKind is async, return ? AsyncIteratorClose(iteratorRecord, status).
  1091. return async_iterator_close(vm, iterator, move(status));
  1092. }
  1093. // o. If result.[[Value]] is not empty, set V to result.[[Value]].
  1094. if (result.value().has_value())
  1095. last_value = *result.value();
  1096. }
  1097. VERIFY_NOT_REACHED();
  1098. }
  1099. // 13.6.1 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-exp-operator-runtime-semantics-evaluation
  1100. // 13.7.1 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-multiplicative-operators-runtime-semantics-evaluation
  1101. // 13.8.1.1 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-addition-operator-plus-runtime-semantics-evaluation
  1102. // 13.8.2.1 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-subtraction-operator-minus-runtime-semantics-evaluation
  1103. // 13.9.1.1 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-left-shift-operator-runtime-semantics-evaluation
  1104. // 13.9.2.1 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-signed-right-shift-operator-runtime-semantics-evaluation
  1105. // 13.9.3.1 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-unsigned-right-shift-operator-runtime-semantics-evaluation
  1106. // 13.10.1 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-relational-operators-runtime-semantics-evaluation
  1107. // 13.11.1 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-equality-operators-runtime-semantics-evaluation
  1108. Completion BinaryExpression::execute(Interpreter& interpreter) const
  1109. {
  1110. InterpreterNodeScope node_scope { interpreter, *this };
  1111. auto& vm = interpreter.vm();
  1112. // Special case in which we cannot execute the lhs. RelationalExpression : PrivateIdentifier in ShiftExpression
  1113. // RelationalExpression : PrivateIdentifier in ShiftExpression, https://tc39.es/ecma262/#sec-relational-operators-runtime-semantics-evaluation
  1114. if (m_op == BinaryOp::In && is<PrivateIdentifier>(*m_lhs)) {
  1115. auto& private_identifier = static_cast<PrivateIdentifier const&>(*m_lhs).string();
  1116. auto rhs_result = TRY(m_rhs->execute(interpreter)).release_value();
  1117. if (!rhs_result.is_object())
  1118. return interpreter.vm().throw_completion<TypeError>(ErrorType::InOperatorWithObject);
  1119. auto private_environment = interpreter.vm().running_execution_context().private_environment;
  1120. VERIFY(private_environment);
  1121. auto private_name = private_environment->resolve_private_identifier(private_identifier);
  1122. return Value(rhs_result.as_object().private_element_find(private_name) != nullptr);
  1123. }
  1124. auto lhs_result = TRY(m_lhs->execute(interpreter)).release_value();
  1125. auto rhs_result = TRY(m_rhs->execute(interpreter)).release_value();
  1126. switch (m_op) {
  1127. case BinaryOp::Addition:
  1128. return TRY(add(vm, lhs_result, rhs_result));
  1129. case BinaryOp::Subtraction:
  1130. return TRY(sub(vm, lhs_result, rhs_result));
  1131. case BinaryOp::Multiplication:
  1132. return TRY(mul(vm, lhs_result, rhs_result));
  1133. case BinaryOp::Division:
  1134. return TRY(div(vm, lhs_result, rhs_result));
  1135. case BinaryOp::Modulo:
  1136. return TRY(mod(vm, lhs_result, rhs_result));
  1137. case BinaryOp::Exponentiation:
  1138. return TRY(exp(vm, lhs_result, rhs_result));
  1139. case BinaryOp::StrictlyEquals:
  1140. return Value(is_strictly_equal(lhs_result, rhs_result));
  1141. case BinaryOp::StrictlyInequals:
  1142. return Value(!is_strictly_equal(lhs_result, rhs_result));
  1143. case BinaryOp::LooselyEquals:
  1144. return Value(TRY(is_loosely_equal(vm, lhs_result, rhs_result)));
  1145. case BinaryOp::LooselyInequals:
  1146. return Value(!TRY(is_loosely_equal(vm, lhs_result, rhs_result)));
  1147. case BinaryOp::GreaterThan:
  1148. return TRY(greater_than(vm, lhs_result, rhs_result));
  1149. case BinaryOp::GreaterThanEquals:
  1150. return TRY(greater_than_equals(vm, lhs_result, rhs_result));
  1151. case BinaryOp::LessThan:
  1152. return TRY(less_than(vm, lhs_result, rhs_result));
  1153. case BinaryOp::LessThanEquals:
  1154. return TRY(less_than_equals(vm, lhs_result, rhs_result));
  1155. case BinaryOp::BitwiseAnd:
  1156. return TRY(bitwise_and(vm, lhs_result, rhs_result));
  1157. case BinaryOp::BitwiseOr:
  1158. return TRY(bitwise_or(vm, lhs_result, rhs_result));
  1159. case BinaryOp::BitwiseXor:
  1160. return TRY(bitwise_xor(vm, lhs_result, rhs_result));
  1161. case BinaryOp::LeftShift:
  1162. return TRY(left_shift(vm, lhs_result, rhs_result));
  1163. case BinaryOp::RightShift:
  1164. return TRY(right_shift(vm, lhs_result, rhs_result));
  1165. case BinaryOp::UnsignedRightShift:
  1166. return TRY(unsigned_right_shift(vm, lhs_result, rhs_result));
  1167. case BinaryOp::In:
  1168. return TRY(in(vm, lhs_result, rhs_result));
  1169. case BinaryOp::InstanceOf:
  1170. return TRY(instance_of(vm, lhs_result, rhs_result));
  1171. }
  1172. VERIFY_NOT_REACHED();
  1173. }
  1174. // 13.13.1 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-binary-logical-operators-runtime-semantics-evaluation
  1175. Completion LogicalExpression::execute(Interpreter& interpreter) const
  1176. {
  1177. InterpreterNodeScope node_scope { interpreter, *this };
  1178. // 1. Let lref be the result of evaluating <Expression>.
  1179. // 2. Let lval be ? GetValue(lref).
  1180. auto lhs_result = TRY(m_lhs->execute(interpreter)).release_value();
  1181. switch (m_op) {
  1182. // LogicalANDExpression : LogicalANDExpression && BitwiseORExpression
  1183. case LogicalOp::And:
  1184. // 3. Let lbool be ToBoolean(lval).
  1185. // 4. If lbool is false, return lval.
  1186. if (!lhs_result.to_boolean())
  1187. return lhs_result;
  1188. // 5. Let rref be the result of evaluating BitwiseORExpression.
  1189. // 6. Return ? GetValue(rref).
  1190. return m_rhs->execute(interpreter);
  1191. // LogicalORExpression : LogicalORExpression || LogicalANDExpression
  1192. case LogicalOp::Or:
  1193. // 3. Let lbool be ToBoolean(lval).
  1194. // 4. If lbool is true, return lval.
  1195. if (lhs_result.to_boolean())
  1196. return lhs_result;
  1197. // 5. Let rref be the result of evaluating LogicalANDExpression.
  1198. // 6. Return ? GetValue(rref).
  1199. return m_rhs->execute(interpreter);
  1200. // CoalesceExpression : CoalesceExpressionHead ?? BitwiseORExpression
  1201. case LogicalOp::NullishCoalescing:
  1202. // 3. If lval is undefined or null, then
  1203. if (lhs_result.is_nullish()) {
  1204. // a. Let rref be the result of evaluating BitwiseORExpression.
  1205. // b. Return ? GetValue(rref).
  1206. return m_rhs->execute(interpreter);
  1207. }
  1208. // 4. Otherwise, return lval.
  1209. return lhs_result;
  1210. }
  1211. VERIFY_NOT_REACHED();
  1212. }
  1213. ThrowCompletionOr<Reference> Expression::to_reference(Interpreter&) const
  1214. {
  1215. return Reference {};
  1216. }
  1217. ThrowCompletionOr<Reference> Identifier::to_reference(Interpreter& interpreter) const
  1218. {
  1219. if (m_cached_environment_coordinate.is_valid()) {
  1220. auto environment = interpreter.vm().running_execution_context().lexical_environment;
  1221. for (size_t i = 0; i < m_cached_environment_coordinate.hops; ++i)
  1222. environment = environment->outer_environment();
  1223. VERIFY(environment);
  1224. VERIFY(environment->is_declarative_environment());
  1225. if (!environment->is_permanently_screwed_by_eval()) {
  1226. return Reference { *environment, string(), interpreter.vm().in_strict_mode(), m_cached_environment_coordinate };
  1227. }
  1228. m_cached_environment_coordinate = {};
  1229. }
  1230. auto reference = TRY(interpreter.vm().resolve_binding(string()));
  1231. if (reference.environment_coordinate().has_value())
  1232. m_cached_environment_coordinate = reference.environment_coordinate().value();
  1233. return reference;
  1234. }
  1235. ThrowCompletionOr<Reference> MemberExpression::to_reference(Interpreter& interpreter) const
  1236. {
  1237. auto& vm = interpreter.vm();
  1238. // 13.3.7.1 Runtime Semantics: Evaluation
  1239. // SuperProperty : super [ Expression ]
  1240. // SuperProperty : super . IdentifierName
  1241. // https://tc39.es/ecma262/#sec-super-keyword-runtime-semantics-evaluation
  1242. if (is<SuperExpression>(object())) {
  1243. // 1. Let env be GetThisEnvironment().
  1244. auto environment = get_this_environment(vm);
  1245. // 2. Let actualThis be ? env.GetThisBinding().
  1246. auto actual_this = TRY(environment->get_this_binding(vm));
  1247. PropertyKey property_key;
  1248. if (is_computed()) {
  1249. // SuperProperty : super [ Expression ]
  1250. // 3. Let propertyNameReference be the result of evaluating Expression.
  1251. // 4. Let propertyNameValue be ? GetValue(propertyNameReference).
  1252. auto property_name_value = TRY(m_property->execute(interpreter)).release_value();
  1253. // 5. Let propertyKey be ? ToPropertyKey(propertyNameValue).
  1254. property_key = TRY(property_name_value.to_property_key(vm));
  1255. } else {
  1256. // SuperProperty : super . IdentifierName
  1257. // 3. Let propertyKey be StringValue of IdentifierName.
  1258. VERIFY(is<Identifier>(property()));
  1259. property_key = static_cast<Identifier const&>(property()).string();
  1260. }
  1261. // 6. If the source text matched by this SuperProperty is strict mode code, let strict be true; else let strict be false.
  1262. bool strict = interpreter.vm().in_strict_mode();
  1263. // 7. Return ? MakeSuperPropertyReference(actualThis, propertyKey, strict).
  1264. return TRY(make_super_property_reference(vm, actual_this, property_key, strict));
  1265. }
  1266. auto base_reference = TRY(m_object->to_reference(interpreter));
  1267. Value base_value;
  1268. if (base_reference.is_valid_reference())
  1269. base_value = TRY(base_reference.get_value(vm));
  1270. else
  1271. base_value = TRY(m_object->execute(interpreter)).release_value();
  1272. VERIFY(!base_value.is_empty());
  1273. // From here on equivalent to
  1274. // 13.3.4 EvaluatePropertyAccessWithIdentifierKey ( baseValue, identifierName, strict ), https://tc39.es/ecma262/#sec-evaluate-property-access-with-identifier-key
  1275. PropertyKey property_key;
  1276. if (is_computed()) {
  1277. // Weird order which I can't quite find from the specs.
  1278. auto value = TRY(m_property->execute(interpreter)).release_value();
  1279. VERIFY(!value.is_empty());
  1280. TRY(require_object_coercible(vm, base_value));
  1281. property_key = TRY(value.to_property_key(vm));
  1282. } else if (is<PrivateIdentifier>(*m_property)) {
  1283. auto& private_identifier = static_cast<PrivateIdentifier const&>(*m_property);
  1284. return make_private_reference(interpreter.vm(), base_value, private_identifier.string());
  1285. } else {
  1286. property_key = verify_cast<Identifier>(*m_property).string();
  1287. TRY(require_object_coercible(vm, base_value));
  1288. }
  1289. if (!property_key.is_valid())
  1290. return Reference {};
  1291. auto strict = interpreter.vm().in_strict_mode();
  1292. return Reference { base_value, move(property_key), {}, strict };
  1293. }
  1294. // 13.5.1.2 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-delete-operator-runtime-semantics-evaluation
  1295. // 13.5.2.1 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-void-operator-runtime-semantics-evaluation
  1296. // 13.5.3.1 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-typeof-operator-runtime-semantics-evaluation
  1297. // 13.5.4.1 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-unary-plus-operator-runtime-semantics-evaluation
  1298. // 13.5.5.1 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-unary-minus-operator-runtime-semantics-evaluation
  1299. // 13.5.6.1 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-bitwise-not-operator-runtime-semantics-evaluation
  1300. // 13.5.7.1 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-logical-not-operator-runtime-semantics-evaluation
  1301. Completion UnaryExpression::execute(Interpreter& interpreter) const
  1302. {
  1303. InterpreterNodeScope node_scope { interpreter, *this };
  1304. auto& vm = interpreter.vm();
  1305. if (m_op == UnaryOp::Delete) {
  1306. auto reference = TRY(m_lhs->to_reference(interpreter));
  1307. return Value(TRY(reference.delete_(vm)));
  1308. }
  1309. Value lhs_result;
  1310. if (m_op == UnaryOp::Typeof && is<Identifier>(*m_lhs)) {
  1311. auto reference = TRY(m_lhs->to_reference(interpreter));
  1312. if (reference.is_unresolvable())
  1313. lhs_result = js_undefined();
  1314. else
  1315. lhs_result = TRY(reference.get_value(vm));
  1316. VERIFY(!lhs_result.is_empty());
  1317. } else {
  1318. // 1. Let expr be the result of evaluating UnaryExpression.
  1319. lhs_result = TRY(m_lhs->execute(interpreter)).release_value();
  1320. }
  1321. switch (m_op) {
  1322. case UnaryOp::BitwiseNot:
  1323. return TRY(bitwise_not(vm, lhs_result));
  1324. case UnaryOp::Not:
  1325. return Value(!lhs_result.to_boolean());
  1326. case UnaryOp::Plus:
  1327. return TRY(unary_plus(vm, lhs_result));
  1328. case UnaryOp::Minus:
  1329. return TRY(unary_minus(vm, lhs_result));
  1330. case UnaryOp::Typeof:
  1331. return Value { MUST_OR_THROW_OOM(PrimitiveString::create(vm, lhs_result.typeof())) };
  1332. case UnaryOp::Void:
  1333. return js_undefined();
  1334. case UnaryOp::Delete:
  1335. VERIFY_NOT_REACHED();
  1336. }
  1337. VERIFY_NOT_REACHED();
  1338. }
  1339. Completion SuperExpression::execute(Interpreter&) const
  1340. {
  1341. // The semantics for SuperExpression are handled in CallExpression and SuperCall.
  1342. VERIFY_NOT_REACHED();
  1343. }
  1344. Completion ClassElement::execute(Interpreter&) const
  1345. {
  1346. // Note: The semantics of class element are handled in class_element_evaluation
  1347. VERIFY_NOT_REACHED();
  1348. }
  1349. static ThrowCompletionOr<ClassElementName> class_key_to_property_name(VM& vm, Expression const& key)
  1350. {
  1351. if (is<PrivateIdentifier>(key)) {
  1352. auto& private_identifier = static_cast<PrivateIdentifier const&>(key);
  1353. auto private_environment = vm.running_execution_context().private_environment;
  1354. VERIFY(private_environment);
  1355. return ClassElementName { private_environment->resolve_private_identifier(private_identifier.string()) };
  1356. }
  1357. auto prop_key = TRY(vm.execute_ast_node(key));
  1358. if (prop_key.is_object())
  1359. prop_key = TRY(prop_key.to_primitive(vm, Value::PreferredType::String));
  1360. auto property_key = TRY(PropertyKey::from_value(vm, prop_key));
  1361. return ClassElementName { property_key };
  1362. }
  1363. // 15.4.5 Runtime Semantics: MethodDefinitionEvaluation, https://tc39.es/ecma262/#sec-runtime-semantics-methoddefinitionevaluation
  1364. ThrowCompletionOr<ClassElement::ClassValue> ClassMethod::class_element_evaluation(VM& vm, Object& target) const
  1365. {
  1366. auto property_key_or_private_name = TRY(class_key_to_property_name(vm, *m_key));
  1367. auto method_value = TRY(vm.execute_ast_node(*m_function));
  1368. auto function_handle = make_handle(&method_value.as_function());
  1369. auto& method_function = static_cast<ECMAScriptFunctionObject&>(method_value.as_function());
  1370. method_function.make_method(target);
  1371. auto set_function_name = [&](DeprecatedString prefix = "") {
  1372. auto name = property_key_or_private_name.visit(
  1373. [&](PropertyKey const& property_key) -> DeprecatedString {
  1374. if (property_key.is_symbol()) {
  1375. auto description = property_key.as_symbol()->description();
  1376. if (!description.has_value() || description->is_empty())
  1377. return "";
  1378. return DeprecatedString::formatted("[{}]", *description);
  1379. } else {
  1380. return property_key.to_string();
  1381. }
  1382. },
  1383. [&](PrivateName const& private_name) -> DeprecatedString {
  1384. return private_name.description;
  1385. });
  1386. update_function_name(method_value, DeprecatedString::formatted("{}{}{}", prefix, prefix.is_empty() ? "" : " ", name));
  1387. };
  1388. if (property_key_or_private_name.has<PropertyKey>()) {
  1389. auto& property_key = property_key_or_private_name.get<PropertyKey>();
  1390. switch (kind()) {
  1391. case ClassMethod::Kind::Method:
  1392. set_function_name();
  1393. TRY(target.define_property_or_throw(property_key, { .value = method_value, .writable = true, .enumerable = false, .configurable = true }));
  1394. break;
  1395. case ClassMethod::Kind::Getter:
  1396. set_function_name("get");
  1397. TRY(target.define_property_or_throw(property_key, { .get = &method_function, .enumerable = true, .configurable = true }));
  1398. break;
  1399. case ClassMethod::Kind::Setter:
  1400. set_function_name("set");
  1401. TRY(target.define_property_or_throw(property_key, { .set = &method_function, .enumerable = true, .configurable = true }));
  1402. break;
  1403. default:
  1404. VERIFY_NOT_REACHED();
  1405. }
  1406. return ClassValue { normal_completion({}) };
  1407. } else {
  1408. auto& private_name = property_key_or_private_name.get<PrivateName>();
  1409. switch (kind()) {
  1410. case Kind::Method:
  1411. set_function_name();
  1412. return ClassValue { PrivateElement { private_name, PrivateElement::Kind::Method, make_handle(method_value) } };
  1413. case Kind::Getter:
  1414. set_function_name("get");
  1415. return ClassValue { PrivateElement { private_name, PrivateElement::Kind::Accessor, make_handle(Value(Accessor::create(vm, &method_function, nullptr))) } };
  1416. case Kind::Setter:
  1417. set_function_name("set");
  1418. return ClassValue { PrivateElement { private_name, PrivateElement::Kind::Accessor, make_handle(Value(Accessor::create(vm, nullptr, &method_function))) } };
  1419. default:
  1420. VERIFY_NOT_REACHED();
  1421. }
  1422. }
  1423. }
  1424. Completion ClassFieldInitializerStatement::execute(Interpreter& interpreter) const
  1425. {
  1426. // 1. Assert: argumentsList is empty.
  1427. VERIFY(interpreter.vm().argument_count() == 0);
  1428. // 2. Assert: functionObject.[[ClassFieldInitializerName]] is not empty.
  1429. VERIFY(!m_class_field_identifier_name.is_empty());
  1430. // 3. If IsAnonymousFunctionDefinition(AssignmentExpression) is true, then
  1431. // a. Let value be ? NamedEvaluation of Initializer with argument functionObject.[[ClassFieldInitializerName]].
  1432. // 4. Else,
  1433. // a. Let rhs be the result of evaluating AssignmentExpression.
  1434. // b. Let value be ? GetValue(rhs).
  1435. auto value = TRY(interpreter.vm().named_evaluation_if_anonymous_function(m_expression, m_class_field_identifier_name));
  1436. // 5. Return Completion Record { [[Type]]: return, [[Value]]: value, [[Target]]: empty }.
  1437. return { Completion::Type::Return, value, {} };
  1438. }
  1439. void ClassFieldInitializerStatement::dump(int) const
  1440. {
  1441. // This should not be dumped as it is never part of an actual AST.
  1442. VERIFY_NOT_REACHED();
  1443. }
  1444. // 15.7.10 Runtime Semantics: ClassFieldDefinitionEvaluation, https://tc39.es/ecma262/#sec-runtime-semantics-classfielddefinitionevaluation
  1445. ThrowCompletionOr<ClassElement::ClassValue> ClassField::class_element_evaluation(VM& vm, Object& target) const
  1446. {
  1447. auto& realm = *vm.current_realm();
  1448. auto property_key_or_private_name = TRY(class_key_to_property_name(vm, *m_key));
  1449. Handle<ECMAScriptFunctionObject> initializer {};
  1450. if (m_initializer) {
  1451. auto copy_initializer = m_initializer;
  1452. auto name = property_key_or_private_name.visit(
  1453. [&](PropertyKey const& property_key) -> DeprecatedString {
  1454. return property_key.is_number() ? property_key.to_string() : property_key.to_string_or_symbol().to_display_string();
  1455. },
  1456. [&](PrivateName const& private_name) -> DeprecatedString {
  1457. return private_name.description;
  1458. });
  1459. // FIXME: A potential optimization is not creating the functions here since these are never directly accessible.
  1460. auto function_code = create_ast_node<ClassFieldInitializerStatement>(m_initializer->source_range(), copy_initializer.release_nonnull(), name);
  1461. initializer = make_handle(*ECMAScriptFunctionObject::create(realm, DeprecatedString::empty(), DeprecatedString::empty(), *function_code, {}, 0, {}, vm.lexical_environment(), vm.running_execution_context().private_environment, FunctionKind::Normal, true, false, m_contains_direct_call_to_eval, false, property_key_or_private_name));
  1462. initializer->make_method(target);
  1463. }
  1464. return ClassValue {
  1465. ClassFieldDefinition {
  1466. move(property_key_or_private_name),
  1467. move(initializer),
  1468. }
  1469. };
  1470. }
  1471. static Optional<DeprecatedFlyString> nullopt_or_private_identifier_description(Expression const& expression)
  1472. {
  1473. if (is<PrivateIdentifier>(expression))
  1474. return static_cast<PrivateIdentifier const&>(expression).string();
  1475. return {};
  1476. }
  1477. Optional<DeprecatedFlyString> ClassField::private_bound_identifier() const
  1478. {
  1479. return nullopt_or_private_identifier_description(*m_key);
  1480. }
  1481. Optional<DeprecatedFlyString> ClassMethod::private_bound_identifier() const
  1482. {
  1483. return nullopt_or_private_identifier_description(*m_key);
  1484. }
  1485. // 15.7.11 Runtime Semantics: ClassStaticBlockDefinitionEvaluation, https://tc39.es/ecma262/#sec-runtime-semantics-classstaticblockdefinitionevaluation
  1486. ThrowCompletionOr<ClassElement::ClassValue> StaticInitializer::class_element_evaluation(VM& vm, Object& home_object) const
  1487. {
  1488. auto& realm = *vm.current_realm();
  1489. // 1. Let lex be the running execution context's LexicalEnvironment.
  1490. auto lexical_environment = vm.running_execution_context().lexical_environment;
  1491. // 2. Let privateEnv be the running execution context's PrivateEnvironment.
  1492. auto private_environment = vm.running_execution_context().private_environment;
  1493. // 3. Let sourceText be the empty sequence of Unicode code points.
  1494. // 4. Let formalParameters be an instance of the production FormalParameters : [empty] .
  1495. // 5. Let bodyFunction be OrdinaryFunctionCreate(%Function.prototype%, sourceText, formalParameters, ClassStaticBlockBody, non-lexical-this, lex, privateEnv).
  1496. // Note: The function bodyFunction is never directly accessible to ECMAScript code.
  1497. auto body_function = ECMAScriptFunctionObject::create(realm, DeprecatedString::empty(), DeprecatedString::empty(), *m_function_body, {}, 0, m_function_body->local_variables_names(), lexical_environment, private_environment, FunctionKind::Normal, true, false, m_contains_direct_call_to_eval, false);
  1498. // 6. Perform MakeMethod(bodyFunction, homeObject).
  1499. body_function->make_method(home_object);
  1500. // 7. Return the ClassStaticBlockDefinition Record { [[BodyFunction]]: bodyFunction }.
  1501. return ClassValue { normal_completion(body_function) };
  1502. }
  1503. // 15.7.16 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-class-definitions-runtime-semantics-evaluation
  1504. // ClassExpression : class BindingIdentifier ClassTail
  1505. Completion ClassExpression::execute(Interpreter& interpreter) const
  1506. {
  1507. InterpreterNodeScope node_scope { interpreter, *this };
  1508. // 1. Let className be StringValue of BindingIdentifier.
  1509. // 2. Let value be ? ClassDefinitionEvaluation of ClassTail with arguments className and className.
  1510. auto* value = TRY(class_definition_evaluation(interpreter.vm(), name(), name()));
  1511. // 3. Set value.[[SourceText]] to the source text matched by ClassExpression.
  1512. value->set_source_text(m_source_text);
  1513. // 4. Return value.
  1514. return Value { value };
  1515. }
  1516. // 15.7.15 Runtime Semantics: BindingClassDeclarationEvaluation, https://tc39.es/ecma262/#sec-runtime-semantics-bindingclassdeclarationevaluation
  1517. static ThrowCompletionOr<Value> binding_class_declaration_evaluation(Interpreter& interpreter, ClassExpression const& class_expression)
  1518. {
  1519. auto& vm = interpreter.vm();
  1520. // ClassDeclaration : class ClassTail
  1521. if (!class_expression.has_name()) {
  1522. // 1. Let value be ? ClassDefinitionEvaluation of ClassTail with arguments undefined and "default".
  1523. auto value = TRY(class_expression.class_definition_evaluation(vm, {}, "default"));
  1524. // 2. Set value.[[SourceText]] to the source text matched by ClassDeclaration.
  1525. value->set_source_text(class_expression.source_text());
  1526. // 3. Return value.
  1527. return value;
  1528. }
  1529. // ClassDeclaration : class BindingIdentifier ClassTail
  1530. // 1. Let className be StringValue of BindingIdentifier.
  1531. auto class_name = class_expression.name();
  1532. VERIFY(!class_name.is_empty());
  1533. // 2. Let value be ? ClassDefinitionEvaluation of ClassTail with arguments className and className.
  1534. auto value = TRY(class_expression.class_definition_evaluation(vm, class_name, class_name));
  1535. // 3. Set value.[[SourceText]] to the source text matched by ClassDeclaration.
  1536. value->set_source_text(class_expression.source_text());
  1537. // 4. Let env be the running execution context's LexicalEnvironment.
  1538. auto* env = interpreter.lexical_environment();
  1539. // 5. Perform ? InitializeBoundName(className, value, env).
  1540. TRY(initialize_bound_name(vm, class_name, value, env));
  1541. // 6. Return value.
  1542. return value;
  1543. }
  1544. // 15.7.16 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-class-definitions-runtime-semantics-evaluation
  1545. // ClassDeclaration : class BindingIdentifier ClassTail
  1546. Completion ClassDeclaration::execute(Interpreter& interpreter) const
  1547. {
  1548. InterpreterNodeScope node_scope { interpreter, *this };
  1549. // 1. Perform ? BindingClassDeclarationEvaluation of this ClassDeclaration.
  1550. (void)TRY(binding_class_declaration_evaluation(interpreter, m_class_expression));
  1551. // 2. Return empty.
  1552. return Optional<Value> {};
  1553. }
  1554. ThrowCompletionOr<ECMAScriptFunctionObject*> ClassExpression::create_class_constructor(VM& vm, Environment* class_environment, Environment* environment, Value super_class, DeprecatedFlyString const& binding_name, DeprecatedFlyString const& class_name) const
  1555. {
  1556. auto& realm = *vm.current_realm();
  1557. // We might not set the lexical environment but we always want to restore it eventually.
  1558. ArmedScopeGuard restore_environment = [&] {
  1559. vm.running_execution_context().lexical_environment = environment;
  1560. };
  1561. auto outer_private_environment = vm.running_execution_context().private_environment;
  1562. auto class_private_environment = new_private_environment(vm, outer_private_environment);
  1563. auto proto_parent = GCPtr { realm.intrinsics().object_prototype() };
  1564. auto constructor_parent = realm.intrinsics().function_prototype();
  1565. for (auto const& element : m_elements) {
  1566. auto opt_private_name = element->private_bound_identifier();
  1567. if (opt_private_name.has_value())
  1568. class_private_environment->add_private_name({}, opt_private_name.release_value());
  1569. }
  1570. if (!m_super_class.is_null()) {
  1571. if (super_class.is_null()) {
  1572. proto_parent = nullptr;
  1573. } else if (!super_class.is_constructor()) {
  1574. return vm.throw_completion<TypeError>(ErrorType::ClassExtendsValueNotAConstructorOrNull, TRY_OR_THROW_OOM(vm, super_class.to_string_without_side_effects()));
  1575. } else {
  1576. auto super_class_prototype = TRY(super_class.get(vm, vm.names.prototype));
  1577. if (!super_class_prototype.is_null() && !super_class_prototype.is_object())
  1578. return vm.throw_completion<TypeError>(ErrorType::ClassExtendsValueInvalidPrototype, TRY_OR_THROW_OOM(vm, super_class_prototype.to_string_without_side_effects()));
  1579. if (super_class_prototype.is_null())
  1580. proto_parent = nullptr;
  1581. else
  1582. proto_parent = super_class_prototype.as_object();
  1583. constructor_parent = super_class.as_object();
  1584. }
  1585. }
  1586. auto prototype = Object::create(realm, proto_parent);
  1587. VERIFY(prototype);
  1588. vm.running_execution_context().lexical_environment = class_environment;
  1589. vm.running_execution_context().private_environment = class_private_environment;
  1590. ScopeGuard restore_private_environment = [&] {
  1591. vm.running_execution_context().private_environment = outer_private_environment;
  1592. };
  1593. // FIXME: Step 14.a is done in the parser. By using a synthetic super(...args) which does not call @@iterator of %Array.prototype%
  1594. auto const& constructor = *m_constructor;
  1595. auto class_constructor = ECMAScriptFunctionObject::create(
  1596. realm,
  1597. constructor.name(),
  1598. constructor.source_text(),
  1599. constructor.body(),
  1600. constructor.parameters(),
  1601. constructor.function_length(),
  1602. constructor.local_variables_names(),
  1603. vm.lexical_environment(),
  1604. vm.running_execution_context().private_environment,
  1605. constructor.kind(),
  1606. constructor.is_strict_mode(),
  1607. constructor.might_need_arguments_object(),
  1608. constructor.contains_direct_call_to_eval(),
  1609. constructor.is_arrow_function());
  1610. class_constructor->set_name(class_name);
  1611. class_constructor->set_home_object(prototype);
  1612. class_constructor->set_is_class_constructor();
  1613. class_constructor->define_direct_property(vm.names.prototype, prototype, Attribute::Writable);
  1614. TRY(class_constructor->internal_set_prototype_of(constructor_parent));
  1615. if (!m_super_class.is_null())
  1616. class_constructor->set_constructor_kind(ECMAScriptFunctionObject::ConstructorKind::Derived);
  1617. prototype->define_direct_property(vm.names.constructor, class_constructor, Attribute::Writable | Attribute::Configurable);
  1618. using StaticElement = Variant<ClassFieldDefinition, Handle<ECMAScriptFunctionObject>>;
  1619. Vector<PrivateElement> static_private_methods;
  1620. Vector<PrivateElement> instance_private_methods;
  1621. Vector<ClassFieldDefinition> instance_fields;
  1622. Vector<StaticElement> static_elements;
  1623. for (auto const& element : m_elements) {
  1624. // Note: All ClassElementEvaluation start with evaluating the name (or we fake it).
  1625. auto element_value = TRY(element->class_element_evaluation(vm, element->is_static() ? *class_constructor : *prototype));
  1626. if (element_value.has<PrivateElement>()) {
  1627. auto& container = element->is_static() ? static_private_methods : instance_private_methods;
  1628. auto& private_element = element_value.get<PrivateElement>();
  1629. auto added_to_existing = false;
  1630. // FIXME: We can skip this loop in most cases.
  1631. for (auto& existing : container) {
  1632. if (existing.key == private_element.key) {
  1633. VERIFY(existing.kind == PrivateElement::Kind::Accessor);
  1634. VERIFY(private_element.kind == PrivateElement::Kind::Accessor);
  1635. auto& accessor = private_element.value.value().as_accessor();
  1636. if (!accessor.getter())
  1637. existing.value.value().as_accessor().set_setter(accessor.setter());
  1638. else
  1639. existing.value.value().as_accessor().set_getter(accessor.getter());
  1640. added_to_existing = true;
  1641. }
  1642. }
  1643. if (!added_to_existing)
  1644. container.append(move(element_value.get<PrivateElement>()));
  1645. } else if (auto* class_field_definition_ptr = element_value.get_pointer<ClassFieldDefinition>()) {
  1646. if (element->is_static())
  1647. static_elements.append(move(*class_field_definition_ptr));
  1648. else
  1649. instance_fields.append(move(*class_field_definition_ptr));
  1650. } else if (element->class_element_kind() == ClassElement::ElementKind::StaticInitializer) {
  1651. // We use Completion to hold the ClassStaticBlockDefinition Record.
  1652. VERIFY(element_value.has<Completion>() && element_value.get<Completion>().value().has_value());
  1653. auto& element_object = element_value.get<Completion>().value()->as_object();
  1654. VERIFY(is<ECMAScriptFunctionObject>(element_object));
  1655. static_elements.append(make_handle(static_cast<ECMAScriptFunctionObject*>(&element_object)));
  1656. }
  1657. }
  1658. vm.running_execution_context().lexical_environment = environment;
  1659. restore_environment.disarm();
  1660. if (!binding_name.is_null())
  1661. MUST(class_environment->initialize_binding(vm, binding_name, class_constructor, Environment::InitializeBindingHint::Normal));
  1662. for (auto& field : instance_fields)
  1663. class_constructor->add_field(field);
  1664. for (auto& private_method : instance_private_methods)
  1665. class_constructor->add_private_method(private_method);
  1666. for (auto& method : static_private_methods)
  1667. TRY(class_constructor->private_method_or_accessor_add(move(method)));
  1668. for (auto& element : static_elements) {
  1669. TRY(element.visit(
  1670. [&](ClassFieldDefinition& field) -> ThrowCompletionOr<void> {
  1671. return TRY(class_constructor->define_field(field));
  1672. },
  1673. [&](Handle<ECMAScriptFunctionObject> static_block_function) -> ThrowCompletionOr<void> {
  1674. VERIFY(!static_block_function.is_null());
  1675. // We discard any value returned here.
  1676. TRY(call(vm, *static_block_function.cell(), class_constructor));
  1677. return {};
  1678. }));
  1679. }
  1680. class_constructor->set_source_text(source_text());
  1681. return { class_constructor };
  1682. }
  1683. // 15.7.14 Runtime Semantics: ClassDefinitionEvaluation, https://tc39.es/ecma262/#sec-runtime-semantics-classdefinitionevaluation
  1684. ThrowCompletionOr<ECMAScriptFunctionObject*> ClassExpression::class_definition_evaluation(VM& vm, DeprecatedFlyString const& binding_name, DeprecatedFlyString const& class_name) const
  1685. {
  1686. auto* environment = vm.lexical_environment();
  1687. VERIFY(environment);
  1688. auto class_environment = new_declarative_environment(*environment);
  1689. Value super_class;
  1690. if (!binding_name.is_null())
  1691. MUST(class_environment->create_immutable_binding(vm, binding_name, true));
  1692. if (!m_super_class.is_null()) {
  1693. vm.running_execution_context().lexical_environment = class_environment;
  1694. // Note: Since our execute does evaluation and GetValue in once we must check for a valid reference first
  1695. auto reference = TRY(m_super_class->to_reference(vm.interpreter()));
  1696. if (reference.is_valid_reference()) {
  1697. super_class = TRY(reference.get_value(vm));
  1698. } else {
  1699. super_class = TRY(vm.execute_ast_node(*m_super_class));
  1700. }
  1701. vm.running_execution_context().lexical_environment = environment;
  1702. }
  1703. return create_class_constructor(vm, class_environment, environment, super_class, binding_name, class_name);
  1704. }
  1705. void ASTNode::dump(int indent) const
  1706. {
  1707. print_indent(indent);
  1708. outln("{}", class_name());
  1709. }
  1710. void ScopeNode::dump(int indent) const
  1711. {
  1712. ASTNode::dump(indent);
  1713. if (!m_lexical_declarations.is_empty()) {
  1714. print_indent(indent + 1);
  1715. outln("(Lexical declarations)");
  1716. for (auto& declaration : m_lexical_declarations)
  1717. declaration->dump(indent + 2);
  1718. }
  1719. if (!m_var_declarations.is_empty()) {
  1720. print_indent(indent + 1);
  1721. outln("(Variable declarations)");
  1722. for (auto& declaration : m_var_declarations)
  1723. declaration->dump(indent + 2);
  1724. }
  1725. if (!m_functions_hoistable_with_annexB_extension.is_empty()) {
  1726. print_indent(indent + 1);
  1727. outln("(Hoisted functions via annexB extension)");
  1728. for (auto& declaration : m_functions_hoistable_with_annexB_extension)
  1729. declaration->dump(indent + 2);
  1730. }
  1731. if (!m_children.is_empty()) {
  1732. print_indent(indent + 1);
  1733. outln("(Children)");
  1734. for (auto& child : children())
  1735. child->dump(indent + 2);
  1736. }
  1737. }
  1738. void BinaryExpression::dump(int indent) const
  1739. {
  1740. char const* op_string = nullptr;
  1741. switch (m_op) {
  1742. case BinaryOp::Addition:
  1743. op_string = "+";
  1744. break;
  1745. case BinaryOp::Subtraction:
  1746. op_string = "-";
  1747. break;
  1748. case BinaryOp::Multiplication:
  1749. op_string = "*";
  1750. break;
  1751. case BinaryOp::Division:
  1752. op_string = "/";
  1753. break;
  1754. case BinaryOp::Modulo:
  1755. op_string = "%";
  1756. break;
  1757. case BinaryOp::Exponentiation:
  1758. op_string = "**";
  1759. break;
  1760. case BinaryOp::StrictlyEquals:
  1761. op_string = "===";
  1762. break;
  1763. case BinaryOp::StrictlyInequals:
  1764. op_string = "!==";
  1765. break;
  1766. case BinaryOp::LooselyEquals:
  1767. op_string = "==";
  1768. break;
  1769. case BinaryOp::LooselyInequals:
  1770. op_string = "!=";
  1771. break;
  1772. case BinaryOp::GreaterThan:
  1773. op_string = ">";
  1774. break;
  1775. case BinaryOp::GreaterThanEquals:
  1776. op_string = ">=";
  1777. break;
  1778. case BinaryOp::LessThan:
  1779. op_string = "<";
  1780. break;
  1781. case BinaryOp::LessThanEquals:
  1782. op_string = "<=";
  1783. break;
  1784. case BinaryOp::BitwiseAnd:
  1785. op_string = "&";
  1786. break;
  1787. case BinaryOp::BitwiseOr:
  1788. op_string = "|";
  1789. break;
  1790. case BinaryOp::BitwiseXor:
  1791. op_string = "^";
  1792. break;
  1793. case BinaryOp::LeftShift:
  1794. op_string = "<<";
  1795. break;
  1796. case BinaryOp::RightShift:
  1797. op_string = ">>";
  1798. break;
  1799. case BinaryOp::UnsignedRightShift:
  1800. op_string = ">>>";
  1801. break;
  1802. case BinaryOp::In:
  1803. op_string = "in";
  1804. break;
  1805. case BinaryOp::InstanceOf:
  1806. op_string = "instanceof";
  1807. break;
  1808. }
  1809. print_indent(indent);
  1810. outln("{}", class_name());
  1811. m_lhs->dump(indent + 1);
  1812. print_indent(indent + 1);
  1813. outln("{}", op_string);
  1814. m_rhs->dump(indent + 1);
  1815. }
  1816. void LogicalExpression::dump(int indent) const
  1817. {
  1818. char const* op_string = nullptr;
  1819. switch (m_op) {
  1820. case LogicalOp::And:
  1821. op_string = "&&";
  1822. break;
  1823. case LogicalOp::Or:
  1824. op_string = "||";
  1825. break;
  1826. case LogicalOp::NullishCoalescing:
  1827. op_string = "??";
  1828. break;
  1829. }
  1830. print_indent(indent);
  1831. outln("{}", class_name());
  1832. m_lhs->dump(indent + 1);
  1833. print_indent(indent + 1);
  1834. outln("{}", op_string);
  1835. m_rhs->dump(indent + 1);
  1836. }
  1837. void UnaryExpression::dump(int indent) const
  1838. {
  1839. char const* op_string = nullptr;
  1840. switch (m_op) {
  1841. case UnaryOp::BitwiseNot:
  1842. op_string = "~";
  1843. break;
  1844. case UnaryOp::Not:
  1845. op_string = "!";
  1846. break;
  1847. case UnaryOp::Plus:
  1848. op_string = "+";
  1849. break;
  1850. case UnaryOp::Minus:
  1851. op_string = "-";
  1852. break;
  1853. case UnaryOp::Typeof:
  1854. op_string = "typeof ";
  1855. break;
  1856. case UnaryOp::Void:
  1857. op_string = "void ";
  1858. break;
  1859. case UnaryOp::Delete:
  1860. op_string = "delete ";
  1861. break;
  1862. }
  1863. print_indent(indent);
  1864. outln("{}", class_name());
  1865. print_indent(indent + 1);
  1866. outln("{}", op_string);
  1867. m_lhs->dump(indent + 1);
  1868. }
  1869. void CallExpression::dump(int indent) const
  1870. {
  1871. print_indent(indent);
  1872. if (is<NewExpression>(*this))
  1873. outln("CallExpression [new]");
  1874. else
  1875. outln("CallExpression");
  1876. m_callee->dump(indent + 1);
  1877. for (auto& argument : arguments())
  1878. argument.value->dump(indent + 1);
  1879. }
  1880. void SuperCall::dump(int indent) const
  1881. {
  1882. print_indent(indent);
  1883. outln("SuperCall");
  1884. for (auto& argument : m_arguments)
  1885. argument.value->dump(indent + 1);
  1886. }
  1887. void ClassDeclaration::dump(int indent) const
  1888. {
  1889. ASTNode::dump(indent);
  1890. m_class_expression->dump(indent + 1);
  1891. }
  1892. ThrowCompletionOr<void> ClassDeclaration::for_each_bound_name(ThrowCompletionOrVoidCallback<DeprecatedFlyString const&>&& callback) const
  1893. {
  1894. if (m_class_expression->name().is_empty())
  1895. return {};
  1896. return callback(m_class_expression->name());
  1897. }
  1898. ThrowCompletionOr<void> ClassDeclaration::for_each_bound_identifier(ThrowCompletionOrVoidCallback<Identifier const&>&& callback) const
  1899. {
  1900. if (!m_class_expression->m_name)
  1901. return {};
  1902. return callback(*m_class_expression->m_name);
  1903. }
  1904. void ClassExpression::dump(int indent) const
  1905. {
  1906. print_indent(indent);
  1907. outln("ClassExpression: \"{}\"", name());
  1908. print_indent(indent);
  1909. outln("(Constructor)");
  1910. m_constructor->dump(indent + 1);
  1911. if (!m_super_class.is_null()) {
  1912. print_indent(indent);
  1913. outln("(Super Class)");
  1914. m_super_class->dump(indent + 1);
  1915. }
  1916. print_indent(indent);
  1917. outln("(Elements)");
  1918. for (auto& method : m_elements)
  1919. method->dump(indent + 1);
  1920. }
  1921. void ClassMethod::dump(int indent) const
  1922. {
  1923. ASTNode::dump(indent);
  1924. print_indent(indent);
  1925. outln("(Key)");
  1926. m_key->dump(indent + 1);
  1927. char const* kind_string = nullptr;
  1928. switch (m_kind) {
  1929. case Kind::Method:
  1930. kind_string = "Method";
  1931. break;
  1932. case Kind::Getter:
  1933. kind_string = "Getter";
  1934. break;
  1935. case Kind::Setter:
  1936. kind_string = "Setter";
  1937. break;
  1938. }
  1939. print_indent(indent);
  1940. outln("Kind: {}", kind_string);
  1941. print_indent(indent);
  1942. outln("Static: {}", is_static());
  1943. print_indent(indent);
  1944. outln("(Function)");
  1945. m_function->dump(indent + 1);
  1946. }
  1947. void ClassField::dump(int indent) const
  1948. {
  1949. ASTNode::dump(indent);
  1950. print_indent(indent);
  1951. outln("(Key)");
  1952. m_key->dump(indent + 1);
  1953. print_indent(indent);
  1954. outln("Static: {}", is_static());
  1955. if (m_initializer) {
  1956. print_indent(indent);
  1957. outln("(Initializer)");
  1958. m_initializer->dump(indent + 1);
  1959. }
  1960. }
  1961. void StaticInitializer::dump(int indent) const
  1962. {
  1963. ASTNode::dump(indent);
  1964. m_function_body->dump(indent + 1);
  1965. }
  1966. void StringLiteral::dump(int indent) const
  1967. {
  1968. print_indent(indent);
  1969. outln("StringLiteral \"{}\"", m_value);
  1970. }
  1971. void SuperExpression::dump(int indent) const
  1972. {
  1973. print_indent(indent);
  1974. outln("super");
  1975. }
  1976. void NumericLiteral::dump(int indent) const
  1977. {
  1978. print_indent(indent);
  1979. outln("NumericLiteral {}", m_value);
  1980. }
  1981. void BigIntLiteral::dump(int indent) const
  1982. {
  1983. print_indent(indent);
  1984. outln("BigIntLiteral {}", m_value);
  1985. }
  1986. void BooleanLiteral::dump(int indent) const
  1987. {
  1988. print_indent(indent);
  1989. outln("BooleanLiteral {}", m_value);
  1990. }
  1991. void NullLiteral::dump(int indent) const
  1992. {
  1993. print_indent(indent);
  1994. outln("null");
  1995. }
  1996. bool BindingPattern::contains_expression() const
  1997. {
  1998. for (auto& entry : entries) {
  1999. if (entry.initializer)
  2000. return true;
  2001. if (auto binding_ptr = entry.alias.get_pointer<NonnullRefPtr<BindingPattern const>>(); binding_ptr && (*binding_ptr)->contains_expression())
  2002. return true;
  2003. }
  2004. return false;
  2005. }
  2006. ThrowCompletionOr<void> BindingPattern::for_each_bound_name(ThrowCompletionOrVoidCallback<DeprecatedFlyString const&>&& callback) const
  2007. {
  2008. for (auto const& entry : entries) {
  2009. auto const& alias = entry.alias;
  2010. if (alias.has<NonnullRefPtr<Identifier const>>()) {
  2011. TRY(callback(alias.get<NonnullRefPtr<Identifier const>>()->string()));
  2012. } else if (alias.has<NonnullRefPtr<BindingPattern const>>()) {
  2013. TRY(alias.get<NonnullRefPtr<BindingPattern const>>()->for_each_bound_name(forward<decltype(callback)>(callback)));
  2014. } else {
  2015. auto const& name = entry.name;
  2016. if (name.has<NonnullRefPtr<Identifier const>>())
  2017. TRY(callback(name.get<NonnullRefPtr<Identifier const>>()->string()));
  2018. }
  2019. }
  2020. return {};
  2021. }
  2022. ThrowCompletionOr<void> BindingPattern::for_each_bound_identifier(ThrowCompletionOrVoidCallback<Identifier const&>&& callback) const
  2023. {
  2024. for (auto const& entry : entries) {
  2025. auto const& alias = entry.alias;
  2026. if (alias.has<NonnullRefPtr<Identifier const>>()) {
  2027. TRY(callback(alias.get<NonnullRefPtr<Identifier const>>()));
  2028. } else if (alias.has<NonnullRefPtr<BindingPattern const>>()) {
  2029. TRY(alias.get<NonnullRefPtr<BindingPattern const>>()->for_each_bound_identifier(forward<decltype(callback)>(callback)));
  2030. } else {
  2031. auto const& name = entry.name;
  2032. if (name.has<NonnullRefPtr<Identifier const>>())
  2033. TRY(callback(name.get<NonnullRefPtr<Identifier const>>()));
  2034. }
  2035. }
  2036. return {};
  2037. }
  2038. void BindingPattern::dump(int indent) const
  2039. {
  2040. print_indent(indent);
  2041. outln("BindingPattern {}", kind == Kind::Array ? "Array" : "Object");
  2042. for (auto& entry : entries) {
  2043. print_indent(indent + 1);
  2044. outln("(Property)");
  2045. if (kind == Kind::Object) {
  2046. print_indent(indent + 2);
  2047. outln("(Identifier)");
  2048. if (entry.name.has<NonnullRefPtr<Identifier const>>()) {
  2049. entry.name.get<NonnullRefPtr<Identifier const>>()->dump(indent + 3);
  2050. } else if (entry.name.has<NonnullRefPtr<Expression const>>()) {
  2051. entry.name.get<NonnullRefPtr<Expression const>>()->dump(indent + 3);
  2052. } else {
  2053. VERIFY(entry.name.has<Empty>());
  2054. print_indent(indent + 3);
  2055. outln("<empty>");
  2056. }
  2057. } else if (entry.is_elision()) {
  2058. print_indent(indent + 2);
  2059. outln("(Elision)");
  2060. continue;
  2061. }
  2062. print_indent(indent + 2);
  2063. outln("(Pattern{})", entry.is_rest ? " rest=true" : "");
  2064. if (entry.alias.has<NonnullRefPtr<Identifier const>>()) {
  2065. entry.alias.get<NonnullRefPtr<Identifier const>>()->dump(indent + 3);
  2066. } else if (entry.alias.has<NonnullRefPtr<BindingPattern const>>()) {
  2067. entry.alias.get<NonnullRefPtr<BindingPattern const>>()->dump(indent + 3);
  2068. } else if (entry.alias.has<NonnullRefPtr<MemberExpression const>>()) {
  2069. entry.alias.get<NonnullRefPtr<MemberExpression const>>()->dump(indent + 3);
  2070. } else {
  2071. print_indent(indent + 3);
  2072. outln("<empty>");
  2073. }
  2074. if (entry.initializer) {
  2075. print_indent(indent + 2);
  2076. outln("(Initializer)");
  2077. entry.initializer->dump(indent + 3);
  2078. }
  2079. }
  2080. }
  2081. void FunctionNode::dump(int indent, DeprecatedString const& class_name) const
  2082. {
  2083. print_indent(indent);
  2084. auto is_async = m_kind == FunctionKind::Async || m_kind == FunctionKind::AsyncGenerator;
  2085. auto is_generator = m_kind == FunctionKind::Generator || m_kind == FunctionKind::AsyncGenerator;
  2086. outln("{}{}{} '{}'", class_name, is_async ? " async" : "", is_generator ? "*" : "", name());
  2087. if (m_contains_direct_call_to_eval) {
  2088. print_indent(indent + 1);
  2089. outln("\033[31;1m(direct eval)\033[0m");
  2090. }
  2091. if (!m_parameters.is_empty()) {
  2092. print_indent(indent + 1);
  2093. outln("(Parameters)");
  2094. for (auto& parameter : m_parameters) {
  2095. parameter.binding.visit(
  2096. [&](Identifier const& identifier) {
  2097. if (parameter.is_rest) {
  2098. print_indent(indent + 2);
  2099. out("...");
  2100. identifier.dump(0);
  2101. } else {
  2102. identifier.dump(indent + 2);
  2103. }
  2104. },
  2105. [&](BindingPattern const& pattern) {
  2106. pattern.dump(indent + 2);
  2107. });
  2108. if (parameter.default_value)
  2109. parameter.default_value->dump(indent + 3);
  2110. }
  2111. }
  2112. print_indent(indent + 1);
  2113. outln("(Body)");
  2114. body().dump(indent + 2);
  2115. }
  2116. void FunctionDeclaration::dump(int indent) const
  2117. {
  2118. FunctionNode::dump(indent, class_name());
  2119. }
  2120. ThrowCompletionOr<void> FunctionDeclaration::for_each_bound_name(ThrowCompletionOrVoidCallback<DeprecatedFlyString const&>&& callback) const
  2121. {
  2122. if (name().is_empty())
  2123. return {};
  2124. return callback(name());
  2125. }
  2126. ThrowCompletionOr<void> FunctionDeclaration::for_each_bound_identifier(ThrowCompletionOrVoidCallback<Identifier const&>&& callback) const
  2127. {
  2128. if (!m_name)
  2129. return {};
  2130. return callback(*m_name);
  2131. }
  2132. void FunctionExpression::dump(int indent) const
  2133. {
  2134. FunctionNode::dump(indent, class_name());
  2135. }
  2136. void YieldExpression::dump(int indent) const
  2137. {
  2138. ASTNode::dump(indent);
  2139. if (argument())
  2140. argument()->dump(indent + 1);
  2141. }
  2142. void AwaitExpression::dump(int indent) const
  2143. {
  2144. ASTNode::dump(indent);
  2145. m_argument->dump(indent + 1);
  2146. }
  2147. void ReturnStatement::dump(int indent) const
  2148. {
  2149. ASTNode::dump(indent);
  2150. if (argument())
  2151. argument()->dump(indent + 1);
  2152. }
  2153. void IfStatement::dump(int indent) const
  2154. {
  2155. ASTNode::dump(indent);
  2156. print_indent(indent);
  2157. outln("If");
  2158. predicate().dump(indent + 1);
  2159. consequent().dump(indent + 1);
  2160. if (alternate()) {
  2161. print_indent(indent);
  2162. outln("Else");
  2163. alternate()->dump(indent + 1);
  2164. }
  2165. }
  2166. void WhileStatement::dump(int indent) const
  2167. {
  2168. ASTNode::dump(indent);
  2169. print_indent(indent);
  2170. outln("While");
  2171. test().dump(indent + 1);
  2172. body().dump(indent + 1);
  2173. }
  2174. void WithStatement::dump(int indent) const
  2175. {
  2176. ASTNode::dump(indent);
  2177. print_indent(indent + 1);
  2178. outln("Object");
  2179. object().dump(indent + 2);
  2180. print_indent(indent + 1);
  2181. outln("Body");
  2182. body().dump(indent + 2);
  2183. }
  2184. void DoWhileStatement::dump(int indent) const
  2185. {
  2186. ASTNode::dump(indent);
  2187. print_indent(indent);
  2188. outln("DoWhile");
  2189. test().dump(indent + 1);
  2190. body().dump(indent + 1);
  2191. }
  2192. void ForStatement::dump(int indent) const
  2193. {
  2194. ASTNode::dump(indent);
  2195. print_indent(indent);
  2196. outln("For");
  2197. if (init())
  2198. init()->dump(indent + 1);
  2199. if (test())
  2200. test()->dump(indent + 1);
  2201. if (update())
  2202. update()->dump(indent + 1);
  2203. body().dump(indent + 1);
  2204. }
  2205. void ForInStatement::dump(int indent) const
  2206. {
  2207. ASTNode::dump(indent);
  2208. print_indent(indent);
  2209. outln("ForIn");
  2210. lhs().visit([&](auto& lhs) { lhs->dump(indent + 1); });
  2211. rhs().dump(indent + 1);
  2212. body().dump(indent + 1);
  2213. }
  2214. void ForOfStatement::dump(int indent) const
  2215. {
  2216. ASTNode::dump(indent);
  2217. print_indent(indent);
  2218. outln("ForOf");
  2219. lhs().visit([&](auto& lhs) { lhs->dump(indent + 1); });
  2220. rhs().dump(indent + 1);
  2221. body().dump(indent + 1);
  2222. }
  2223. void ForAwaitOfStatement::dump(int indent) const
  2224. {
  2225. ASTNode::dump(indent);
  2226. print_indent(indent);
  2227. outln("ForAwaitOf");
  2228. m_lhs.visit([&](auto& lhs) { lhs->dump(indent + 1); });
  2229. m_rhs->dump(indent + 1);
  2230. m_body->dump(indent + 1);
  2231. }
  2232. // 13.1.3 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-identifiers-runtime-semantics-evaluation
  2233. Completion Identifier::execute(Interpreter& interpreter) const
  2234. {
  2235. InterpreterNodeScope node_scope { interpreter, *this };
  2236. auto& vm = interpreter.vm();
  2237. // 1. Return ? ResolveBinding(StringValue of Identifier).
  2238. // OPTIMIZATION: We call Identifier::to_reference() here, which acts as a caching layer around ResolveBinding.
  2239. auto reference = TRY(to_reference(interpreter));
  2240. // NOTE: The spec wants us to return the reference directly; this is not possible with ASTNode::execute() (short of letting it return a variant).
  2241. // So, instead of calling GetValue at the call site, we do it here.
  2242. return TRY(reference.get_value(vm));
  2243. }
  2244. void Identifier::dump(int indent) const
  2245. {
  2246. print_indent(indent);
  2247. if (is_local()) {
  2248. outln("Identifier \"{}\" is_local=(true) index=({})", m_string, m_local_variable_index);
  2249. } else if (is_global()) {
  2250. outln("Identifier \"{}\" is_global=(true)", m_string);
  2251. } else {
  2252. outln("Identifier \"{}\"", m_string);
  2253. }
  2254. }
  2255. Completion PrivateIdentifier::execute(Interpreter&) const
  2256. {
  2257. // Note: This should be handled by either the member expression this is part of
  2258. // or the binary expression in the case of `#foo in bar`.
  2259. VERIFY_NOT_REACHED();
  2260. }
  2261. void PrivateIdentifier::dump(int indent) const
  2262. {
  2263. print_indent(indent);
  2264. outln("PrivateIdentifier \"{}\"", m_string);
  2265. }
  2266. void SpreadExpression::dump(int indent) const
  2267. {
  2268. ASTNode::dump(indent);
  2269. m_target->dump(indent + 1);
  2270. }
  2271. Completion SpreadExpression::execute(Interpreter& interpreter) const
  2272. {
  2273. InterpreterNodeScope node_scope { interpreter, *this };
  2274. return m_target->execute(interpreter);
  2275. }
  2276. // 13.2.1.1 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-this-keyword-runtime-semantics-evaluation
  2277. Completion ThisExpression::execute(Interpreter& interpreter) const
  2278. {
  2279. InterpreterNodeScope node_scope { interpreter, *this };
  2280. auto& vm = interpreter.vm();
  2281. // 1. Return ? ResolveThisBinding().
  2282. return vm.resolve_this_binding();
  2283. }
  2284. void ThisExpression::dump(int indent) const
  2285. {
  2286. ASTNode::dump(indent);
  2287. }
  2288. // 13.15.2 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-assignment-operators-runtime-semantics-evaluation
  2289. Completion AssignmentExpression::execute(Interpreter& interpreter) const
  2290. {
  2291. InterpreterNodeScope node_scope { interpreter, *this };
  2292. auto& vm = interpreter.vm();
  2293. if (m_op == AssignmentOp::Assignment) {
  2294. // AssignmentExpression : LeftHandSideExpression = AssignmentExpression
  2295. return m_lhs.visit(
  2296. // 1. If LeftHandSideExpression is neither an ObjectLiteral nor an ArrayLiteral, then
  2297. [&](NonnullRefPtr<Expression const> const& lhs) -> ThrowCompletionOr<Value> {
  2298. // a. Let lref be the result of evaluating LeftHandSideExpression.
  2299. // b. ReturnIfAbrupt(lref).
  2300. auto reference = TRY(lhs->to_reference(interpreter));
  2301. Value rhs_result;
  2302. // c. If IsAnonymousFunctionDefinition(AssignmentExpression) and IsIdentifierRef of LeftHandSideExpression are both true, then
  2303. if (lhs->is_identifier()) {
  2304. // i. Let rval be ? NamedEvaluation of AssignmentExpression with argument lref.[[ReferencedName]].
  2305. auto& identifier_name = static_cast<Identifier const&>(*lhs).string();
  2306. rhs_result = TRY(vm.named_evaluation_if_anonymous_function(m_rhs, identifier_name));
  2307. }
  2308. // d. Else,
  2309. else {
  2310. // i. Let rref be the result of evaluating AssignmentExpression.
  2311. // ii. Let rval be ? GetValue(rref).
  2312. rhs_result = TRY(m_rhs->execute(interpreter)).release_value();
  2313. }
  2314. // e. Perform ? PutValue(lref, rval).
  2315. TRY(reference.put_value(vm, rhs_result));
  2316. // f. Return rval.
  2317. return rhs_result;
  2318. },
  2319. // 2. Let assignmentPattern be the AssignmentPattern that is covered by LeftHandSideExpression.
  2320. [&](NonnullRefPtr<BindingPattern const> const& pattern) -> ThrowCompletionOr<Value> {
  2321. // 3. Let rref be the result of evaluating AssignmentExpression.
  2322. // 4. Let rval be ? GetValue(rref).
  2323. auto rhs_result = TRY(m_rhs->execute(interpreter)).release_value();
  2324. // 5. Perform ? DestructuringAssignmentEvaluation of assignmentPattern with argument rval.
  2325. TRY(vm.destructuring_assignment_evaluation(pattern, rhs_result));
  2326. // 6. Return rval.
  2327. return rhs_result;
  2328. });
  2329. }
  2330. VERIFY(m_lhs.has<NonnullRefPtr<Expression const>>());
  2331. // 1. Let lref be the result of evaluating LeftHandSideExpression.
  2332. auto& lhs_expression = *m_lhs.get<NonnullRefPtr<Expression const>>();
  2333. auto reference = TRY(lhs_expression.to_reference(interpreter));
  2334. // 2. Let lval be ? GetValue(lref).
  2335. auto lhs_result = TRY(reference.get_value(vm));
  2336. // AssignmentExpression : LeftHandSideExpression {&&=, ||=, ??=} AssignmentExpression
  2337. if (m_op == AssignmentOp::AndAssignment || m_op == AssignmentOp::OrAssignment || m_op == AssignmentOp::NullishAssignment) {
  2338. switch (m_op) {
  2339. // AssignmentExpression : LeftHandSideExpression &&= AssignmentExpression
  2340. case AssignmentOp::AndAssignment:
  2341. // 3. Let lbool be ToBoolean(lval).
  2342. // 4. If lbool is false, return lval.
  2343. if (!lhs_result.to_boolean())
  2344. return lhs_result;
  2345. break;
  2346. // AssignmentExpression : LeftHandSideExpression ||= AssignmentExpression
  2347. case AssignmentOp::OrAssignment:
  2348. // 3. Let lbool be ToBoolean(lval).
  2349. // 4. If lbool is true, return lval.
  2350. if (lhs_result.to_boolean())
  2351. return lhs_result;
  2352. break;
  2353. // AssignmentExpression : LeftHandSideExpression ??= AssignmentExpression
  2354. case AssignmentOp::NullishAssignment:
  2355. // 3. If lval is neither undefined nor null, return lval.
  2356. if (!lhs_result.is_nullish())
  2357. return lhs_result;
  2358. break;
  2359. default:
  2360. VERIFY_NOT_REACHED();
  2361. }
  2362. Value rhs_result;
  2363. // 5. If IsAnonymousFunctionDefinition(AssignmentExpression) is true and IsIdentifierRef of LeftHandSideExpression is true, then
  2364. if (lhs_expression.is_identifier()) {
  2365. // a. Let rval be ? NamedEvaluation of AssignmentExpression with argument lref.[[ReferencedName]].
  2366. auto& identifier_name = static_cast<Identifier const&>(lhs_expression).string();
  2367. rhs_result = TRY(interpreter.vm().named_evaluation_if_anonymous_function(m_rhs, identifier_name));
  2368. }
  2369. // 6. Else,
  2370. else {
  2371. // a. Let rref be the result of evaluating AssignmentExpression.
  2372. // b. Let rval be ? GetValue(rref).
  2373. rhs_result = TRY(m_rhs->execute(interpreter)).release_value();
  2374. }
  2375. // 7. Perform ? PutValue(lref, rval).
  2376. TRY(reference.put_value(vm, rhs_result));
  2377. // 8. Return rval.
  2378. return rhs_result;
  2379. }
  2380. // AssignmentExpression : LeftHandSideExpression AssignmentOperator AssignmentExpression
  2381. // 3. Let rref be the result of evaluating AssignmentExpression.
  2382. // 4. Let rval be ? GetValue(rref).
  2383. auto rhs_result = TRY(m_rhs->execute(interpreter)).release_value();
  2384. // 5. Let assignmentOpText be the source text matched by AssignmentOperator.
  2385. // 6. Let opText be the sequence of Unicode code points associated with assignmentOpText in the following table:
  2386. // 7. Let r be ? ApplyStringOrNumericBinaryOperator(lval, opText, rval).
  2387. switch (m_op) {
  2388. case AssignmentOp::AdditionAssignment:
  2389. rhs_result = TRY(add(vm, lhs_result, rhs_result));
  2390. break;
  2391. case AssignmentOp::SubtractionAssignment:
  2392. rhs_result = TRY(sub(vm, lhs_result, rhs_result));
  2393. break;
  2394. case AssignmentOp::MultiplicationAssignment:
  2395. rhs_result = TRY(mul(vm, lhs_result, rhs_result));
  2396. break;
  2397. case AssignmentOp::DivisionAssignment:
  2398. rhs_result = TRY(div(vm, lhs_result, rhs_result));
  2399. break;
  2400. case AssignmentOp::ModuloAssignment:
  2401. rhs_result = TRY(mod(vm, lhs_result, rhs_result));
  2402. break;
  2403. case AssignmentOp::ExponentiationAssignment:
  2404. rhs_result = TRY(exp(vm, lhs_result, rhs_result));
  2405. break;
  2406. case AssignmentOp::BitwiseAndAssignment:
  2407. rhs_result = TRY(bitwise_and(vm, lhs_result, rhs_result));
  2408. break;
  2409. case AssignmentOp::BitwiseOrAssignment:
  2410. rhs_result = TRY(bitwise_or(vm, lhs_result, rhs_result));
  2411. break;
  2412. case AssignmentOp::BitwiseXorAssignment:
  2413. rhs_result = TRY(bitwise_xor(vm, lhs_result, rhs_result));
  2414. break;
  2415. case AssignmentOp::LeftShiftAssignment:
  2416. rhs_result = TRY(left_shift(vm, lhs_result, rhs_result));
  2417. break;
  2418. case AssignmentOp::RightShiftAssignment:
  2419. rhs_result = TRY(right_shift(vm, lhs_result, rhs_result));
  2420. break;
  2421. case AssignmentOp::UnsignedRightShiftAssignment:
  2422. rhs_result = TRY(unsigned_right_shift(vm, lhs_result, rhs_result));
  2423. break;
  2424. case AssignmentOp::Assignment:
  2425. case AssignmentOp::AndAssignment:
  2426. case AssignmentOp::OrAssignment:
  2427. case AssignmentOp::NullishAssignment:
  2428. VERIFY_NOT_REACHED();
  2429. }
  2430. // 8. Perform ? PutValue(lref, r).
  2431. TRY(reference.put_value(vm, rhs_result));
  2432. // 9. Return r.
  2433. return rhs_result;
  2434. }
  2435. // 13.4.2.1 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-postfix-increment-operator-runtime-semantics-evaluation
  2436. // 13.4.3.1 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-postfix-decrement-operator-runtime-semantics-evaluation
  2437. // 13.4.4.1 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-prefix-increment-operator-runtime-semantics-evaluation
  2438. // 13.4.5.1 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-prefix-decrement-operator-runtime-semantics-evaluation
  2439. Completion UpdateExpression::execute(Interpreter& interpreter) const
  2440. {
  2441. InterpreterNodeScope node_scope { interpreter, *this };
  2442. auto& vm = interpreter.vm();
  2443. // 1. Let expr be the result of evaluating <Expression>.
  2444. auto reference = TRY(m_argument->to_reference(interpreter));
  2445. // 2. Let oldValue be ? ToNumeric(? GetValue(expr)).
  2446. auto old_value = TRY(reference.get_value(vm));
  2447. old_value = TRY(old_value.to_numeric(vm));
  2448. Value new_value;
  2449. switch (m_op) {
  2450. case UpdateOp::Increment:
  2451. // 3. If Type(oldValue) is Number, then
  2452. if (old_value.is_number()) {
  2453. // a. Let newValue be Number::add(oldValue, 1𝔽).
  2454. new_value = Value(old_value.as_double() + 1);
  2455. }
  2456. // 4. Else,
  2457. else {
  2458. // a. Assert: Type(oldValue) is BigInt.
  2459. // b. Let newValue be BigInt::add(oldValue, 1ℤ).
  2460. new_value = BigInt::create(vm, old_value.as_bigint().big_integer().plus(Crypto::SignedBigInteger { 1 }));
  2461. }
  2462. break;
  2463. case UpdateOp::Decrement:
  2464. // 3. If Type(oldValue) is Number, then
  2465. if (old_value.is_number()) {
  2466. // a. Let newValue be Number::subtract(oldValue, 1𝔽).
  2467. new_value = Value(old_value.as_double() - 1);
  2468. }
  2469. // 4. Else,
  2470. else {
  2471. // a. Assert: Type(oldValue) is BigInt.
  2472. // b. Let newValue be BigInt::subtract(oldValue, 1ℤ).
  2473. new_value = BigInt::create(vm, old_value.as_bigint().big_integer().minus(Crypto::SignedBigInteger { 1 }));
  2474. }
  2475. break;
  2476. default:
  2477. VERIFY_NOT_REACHED();
  2478. }
  2479. // 5. Perform ? PutValue(expr, newValue).
  2480. TRY(reference.put_value(vm, new_value));
  2481. // 6. Return newValue.
  2482. // 6. Return oldValue.
  2483. return m_prefixed ? new_value : old_value;
  2484. }
  2485. void AssignmentExpression::dump(int indent) const
  2486. {
  2487. char const* op_string = nullptr;
  2488. switch (m_op) {
  2489. case AssignmentOp::Assignment:
  2490. op_string = "=";
  2491. break;
  2492. case AssignmentOp::AdditionAssignment:
  2493. op_string = "+=";
  2494. break;
  2495. case AssignmentOp::SubtractionAssignment:
  2496. op_string = "-=";
  2497. break;
  2498. case AssignmentOp::MultiplicationAssignment:
  2499. op_string = "*=";
  2500. break;
  2501. case AssignmentOp::DivisionAssignment:
  2502. op_string = "/=";
  2503. break;
  2504. case AssignmentOp::ModuloAssignment:
  2505. op_string = "%=";
  2506. break;
  2507. case AssignmentOp::ExponentiationAssignment:
  2508. op_string = "**=";
  2509. break;
  2510. case AssignmentOp::BitwiseAndAssignment:
  2511. op_string = "&=";
  2512. break;
  2513. case AssignmentOp::BitwiseOrAssignment:
  2514. op_string = "|=";
  2515. break;
  2516. case AssignmentOp::BitwiseXorAssignment:
  2517. op_string = "^=";
  2518. break;
  2519. case AssignmentOp::LeftShiftAssignment:
  2520. op_string = "<<=";
  2521. break;
  2522. case AssignmentOp::RightShiftAssignment:
  2523. op_string = ">>=";
  2524. break;
  2525. case AssignmentOp::UnsignedRightShiftAssignment:
  2526. op_string = ">>>=";
  2527. break;
  2528. case AssignmentOp::AndAssignment:
  2529. op_string = "&&=";
  2530. break;
  2531. case AssignmentOp::OrAssignment:
  2532. op_string = "||=";
  2533. break;
  2534. case AssignmentOp::NullishAssignment:
  2535. op_string = "\?\?=";
  2536. break;
  2537. }
  2538. ASTNode::dump(indent);
  2539. print_indent(indent + 1);
  2540. outln("{}", op_string);
  2541. m_lhs.visit([&](auto& lhs) { lhs->dump(indent + 1); });
  2542. m_rhs->dump(indent + 1);
  2543. }
  2544. void UpdateExpression::dump(int indent) const
  2545. {
  2546. char const* op_string = nullptr;
  2547. switch (m_op) {
  2548. case UpdateOp::Increment:
  2549. op_string = "++";
  2550. break;
  2551. case UpdateOp::Decrement:
  2552. op_string = "--";
  2553. break;
  2554. }
  2555. ASTNode::dump(indent);
  2556. if (m_prefixed) {
  2557. print_indent(indent + 1);
  2558. outln("{}", op_string);
  2559. }
  2560. m_argument->dump(indent + 1);
  2561. if (!m_prefixed) {
  2562. print_indent(indent + 1);
  2563. outln("{}", op_string);
  2564. }
  2565. }
  2566. // 14.3.1.2 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-let-and-const-declarations-runtime-semantics-evaluation
  2567. // 14.3.2.1 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-variable-statement-runtime-semantics-evaluation
  2568. Completion VariableDeclaration::execute(Interpreter& interpreter) const
  2569. {
  2570. InterpreterNodeScope node_scope { interpreter, *this };
  2571. auto& vm = interpreter.vm();
  2572. for (auto& declarator : m_declarations) {
  2573. if (auto* init = declarator->init()) {
  2574. TRY(declarator->target().visit(
  2575. [&](NonnullRefPtr<Identifier const> const& id) -> ThrowCompletionOr<void> {
  2576. auto reference = TRY(id->to_reference(interpreter));
  2577. auto initializer_result = TRY(interpreter.vm().named_evaluation_if_anonymous_function(*init, id->string()));
  2578. VERIFY(!initializer_result.is_empty());
  2579. if (m_declaration_kind == DeclarationKind::Var)
  2580. return reference.put_value(vm, initializer_result);
  2581. else
  2582. return reference.initialize_referenced_binding(vm, initializer_result);
  2583. },
  2584. [&](NonnullRefPtr<BindingPattern const> const& pattern) -> ThrowCompletionOr<void> {
  2585. auto initializer_result = TRY(init->execute(interpreter)).release_value();
  2586. Environment* environment = m_declaration_kind == DeclarationKind::Var ? nullptr : interpreter.lexical_environment();
  2587. return vm.binding_initialization(pattern, initializer_result, environment);
  2588. }));
  2589. } else if (m_declaration_kind != DeclarationKind::Var) {
  2590. VERIFY(declarator->target().has<NonnullRefPtr<Identifier const>>());
  2591. auto& identifier = declarator->target().get<NonnullRefPtr<Identifier const>>();
  2592. auto reference = TRY(identifier->to_reference(interpreter));
  2593. TRY(reference.initialize_referenced_binding(vm, js_undefined()));
  2594. }
  2595. }
  2596. return normal_completion({});
  2597. }
  2598. Completion VariableDeclarator::execute(Interpreter& interpreter) const
  2599. {
  2600. InterpreterNodeScope node_scope { interpreter, *this };
  2601. // NOTE: VariableDeclarator execution is handled by VariableDeclaration.
  2602. VERIFY_NOT_REACHED();
  2603. }
  2604. ThrowCompletionOr<void> VariableDeclaration::for_each_bound_name(ThrowCompletionOrVoidCallback<DeprecatedFlyString const&>&& callback) const
  2605. {
  2606. for (auto const& entry : declarations()) {
  2607. TRY(entry->target().visit(
  2608. [&](NonnullRefPtr<Identifier const> const& id) {
  2609. return callback(id->string());
  2610. },
  2611. [&](NonnullRefPtr<BindingPattern const> const& binding) {
  2612. return binding->for_each_bound_identifier([&](auto const& identifier) {
  2613. return callback(identifier.string());
  2614. });
  2615. }));
  2616. }
  2617. return {};
  2618. }
  2619. ThrowCompletionOr<void> VariableDeclaration::for_each_bound_identifier(ThrowCompletionOrVoidCallback<Identifier const&>&& callback) const
  2620. {
  2621. for (auto const& entry : declarations()) {
  2622. TRY(entry->target().visit(
  2623. [&](NonnullRefPtr<Identifier const> const& id) {
  2624. return callback(id);
  2625. },
  2626. [&](NonnullRefPtr<BindingPattern const> const& binding) {
  2627. return binding->for_each_bound_identifier([&](auto const& id) {
  2628. return callback(id);
  2629. });
  2630. }));
  2631. }
  2632. return {};
  2633. }
  2634. void VariableDeclaration::dump(int indent) const
  2635. {
  2636. char const* declaration_kind_string = nullptr;
  2637. switch (m_declaration_kind) {
  2638. case DeclarationKind::Let:
  2639. declaration_kind_string = "Let";
  2640. break;
  2641. case DeclarationKind::Var:
  2642. declaration_kind_string = "Var";
  2643. break;
  2644. case DeclarationKind::Const:
  2645. declaration_kind_string = "Const";
  2646. break;
  2647. }
  2648. ASTNode::dump(indent);
  2649. print_indent(indent + 1);
  2650. outln("{}", declaration_kind_string);
  2651. for (auto& declarator : m_declarations)
  2652. declarator->dump(indent + 1);
  2653. }
  2654. // 6.2.1.2 Runtime Semantics: Evaluation, https://tc39.es/proposal-explicit-resource-management/#sec-let-and-const-declarations-runtime-semantics-evaluation
  2655. Completion UsingDeclaration::execute(Interpreter& interpreter) const
  2656. {
  2657. // 1. Let next be BindingEvaluation of BindingList with parameter sync-dispose.
  2658. InterpreterNodeScope node_scope { interpreter, *this };
  2659. auto& vm = interpreter.vm();
  2660. for (auto& declarator : m_declarations) {
  2661. VERIFY(declarator->target().has<NonnullRefPtr<Identifier const>>());
  2662. VERIFY(declarator->init());
  2663. auto& id = declarator->target().get<NonnullRefPtr<Identifier const>>();
  2664. // 2. ReturnIfAbrupt(next).
  2665. auto reference = TRY(id->to_reference(interpreter));
  2666. auto initializer_result = TRY(interpreter.vm().named_evaluation_if_anonymous_function(*declarator->init(), id->string()));
  2667. VERIFY(!initializer_result.is_empty());
  2668. TRY(reference.initialize_referenced_binding(vm, initializer_result, Environment::InitializeBindingHint::SyncDispose));
  2669. }
  2670. // 3. Return empty.
  2671. return normal_completion({});
  2672. }
  2673. ThrowCompletionOr<void> UsingDeclaration::for_each_bound_name(ThrowCompletionOrVoidCallback<DeprecatedFlyString const&>&& callback) const
  2674. {
  2675. for (auto const& entry : m_declarations) {
  2676. VERIFY(entry->target().has<NonnullRefPtr<Identifier const>>());
  2677. TRY(callback(entry->target().get<NonnullRefPtr<Identifier const>>()->string()));
  2678. }
  2679. return {};
  2680. }
  2681. ThrowCompletionOr<void> UsingDeclaration::for_each_bound_identifier(ThrowCompletionOrVoidCallback<Identifier const&>&& callback) const
  2682. {
  2683. for (auto const& entry : m_declarations) {
  2684. VERIFY(entry->target().has<NonnullRefPtr<Identifier const>>());
  2685. TRY(callback(entry->target().get<NonnullRefPtr<Identifier const>>()));
  2686. }
  2687. return {};
  2688. }
  2689. void UsingDeclaration::dump(int indent) const
  2690. {
  2691. ASTNode::dump(indent);
  2692. print_indent(indent + 1);
  2693. for (auto& declarator : m_declarations)
  2694. declarator->dump(indent + 1);
  2695. }
  2696. void VariableDeclarator::dump(int indent) const
  2697. {
  2698. ASTNode::dump(indent);
  2699. m_target.visit([indent](auto const& value) { value->dump(indent + 1); });
  2700. if (m_init)
  2701. m_init->dump(indent + 1);
  2702. }
  2703. void ObjectProperty::dump(int indent) const
  2704. {
  2705. ASTNode::dump(indent);
  2706. if (m_property_type == Type::Spread) {
  2707. print_indent(indent + 1);
  2708. outln("...Spreading");
  2709. m_key->dump(indent + 1);
  2710. } else {
  2711. m_key->dump(indent + 1);
  2712. m_value->dump(indent + 1);
  2713. }
  2714. }
  2715. void ObjectExpression::dump(int indent) const
  2716. {
  2717. ASTNode::dump(indent);
  2718. for (auto& property : m_properties) {
  2719. property->dump(indent + 1);
  2720. }
  2721. }
  2722. void ExpressionStatement::dump(int indent) const
  2723. {
  2724. ASTNode::dump(indent);
  2725. m_expression->dump(indent + 1);
  2726. }
  2727. Completion ObjectProperty::execute(Interpreter& interpreter) const
  2728. {
  2729. InterpreterNodeScope node_scope { interpreter, *this };
  2730. // NOTE: ObjectProperty execution is handled by ObjectExpression.
  2731. VERIFY_NOT_REACHED();
  2732. }
  2733. // 13.2.5.4 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-object-initializer-runtime-semantics-evaluation
  2734. Completion ObjectExpression::execute(Interpreter& interpreter) const
  2735. {
  2736. InterpreterNodeScope node_scope { interpreter, *this };
  2737. auto& vm = interpreter.vm();
  2738. auto& realm = *vm.current_realm();
  2739. // 1. Let obj be OrdinaryObjectCreate(%Object.prototype%).
  2740. auto object = Object::create(realm, realm.intrinsics().object_prototype());
  2741. // 2. Perform ? PropertyDefinitionEvaluation of PropertyDefinitionList with argument obj.
  2742. for (auto& property : m_properties) {
  2743. auto key = TRY(property->key().execute(interpreter)).release_value();
  2744. // PropertyDefinition : ... AssignmentExpression
  2745. if (property->type() == ObjectProperty::Type::Spread) {
  2746. // 4. Perform ? CopyDataProperties(object, fromValue, excludedNames).
  2747. TRY(object->copy_data_properties(vm, key, {}));
  2748. // 5. Return unused.
  2749. continue;
  2750. }
  2751. auto value = TRY(property->value().execute(interpreter)).release_value();
  2752. // 8. If isProtoSetter is true, then
  2753. if (property->type() == ObjectProperty::Type::ProtoSetter) {
  2754. // a. If Type(propValue) is either Object or Null, then
  2755. if (value.is_object() || value.is_null()) {
  2756. // i. Perform ! object.[[SetPrototypeOf]](propValue).
  2757. MUST(object->internal_set_prototype_of(value.is_object() ? &value.as_object() : nullptr));
  2758. }
  2759. // b. Return unused.
  2760. continue;
  2761. }
  2762. auto property_key = TRY(PropertyKey::from_value(vm, key));
  2763. if (property->is_method()) {
  2764. VERIFY(value.is_function());
  2765. static_cast<ECMAScriptFunctionObject&>(value.as_function()).set_home_object(object);
  2766. auto name = MUST(get_function_property_name(property_key));
  2767. if (property->type() == ObjectProperty::Type::Getter) {
  2768. name = DeprecatedString::formatted("get {}", name);
  2769. } else if (property->type() == ObjectProperty::Type::Setter) {
  2770. name = DeprecatedString::formatted("set {}", name);
  2771. }
  2772. update_function_name(value, name);
  2773. }
  2774. switch (property->type()) {
  2775. case ObjectProperty::Type::Getter:
  2776. VERIFY(value.is_function());
  2777. object->define_direct_accessor(property_key, &value.as_function(), nullptr, Attribute::Configurable | Attribute::Enumerable);
  2778. break;
  2779. case ObjectProperty::Type::Setter:
  2780. VERIFY(value.is_function());
  2781. object->define_direct_accessor(property_key, nullptr, &value.as_function(), Attribute::Configurable | Attribute::Enumerable);
  2782. break;
  2783. case ObjectProperty::Type::KeyValue:
  2784. object->define_direct_property(property_key, value, default_attributes);
  2785. break;
  2786. case ObjectProperty::Type::Spread:
  2787. default:
  2788. VERIFY_NOT_REACHED();
  2789. }
  2790. }
  2791. // 3. Return obj.
  2792. return Value { object };
  2793. }
  2794. void MemberExpression::dump(int indent) const
  2795. {
  2796. print_indent(indent);
  2797. outln("{}(computed={})", class_name(), is_computed());
  2798. m_object->dump(indent + 1);
  2799. m_property->dump(indent + 1);
  2800. }
  2801. DeprecatedString MemberExpression::to_string_approximation() const
  2802. {
  2803. DeprecatedString object_string = "<object>";
  2804. if (is<Identifier>(*m_object))
  2805. object_string = static_cast<Identifier const&>(*m_object).string();
  2806. if (is_computed())
  2807. return DeprecatedString::formatted("{}[<computed>]", object_string);
  2808. if (is<PrivateIdentifier>(*m_property))
  2809. return DeprecatedString::formatted("{}.{}", object_string, verify_cast<PrivateIdentifier>(*m_property).string());
  2810. return DeprecatedString::formatted("{}.{}", object_string, verify_cast<Identifier>(*m_property).string());
  2811. }
  2812. // 13.3.2.1 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-property-accessors-runtime-semantics-evaluation
  2813. Completion MemberExpression::execute(Interpreter& interpreter) const
  2814. {
  2815. InterpreterNodeScope node_scope { interpreter, *this };
  2816. auto& vm = interpreter.vm();
  2817. auto reference = TRY(to_reference(interpreter));
  2818. return TRY(reference.get_value(vm));
  2819. }
  2820. bool MemberExpression::ends_in_private_name() const
  2821. {
  2822. if (is_computed())
  2823. return false;
  2824. if (is<PrivateIdentifier>(*m_property))
  2825. return true;
  2826. if (is<MemberExpression>(*m_property))
  2827. return static_cast<MemberExpression const&>(*m_property).ends_in_private_name();
  2828. return false;
  2829. }
  2830. void OptionalChain::dump(int indent) const
  2831. {
  2832. print_indent(indent);
  2833. outln("{}", class_name());
  2834. m_base->dump(indent + 1);
  2835. for (auto& reference : m_references) {
  2836. reference.visit(
  2837. [&](Call const& call) {
  2838. print_indent(indent + 1);
  2839. outln("Call({})", call.mode == Mode::Optional ? "Optional" : "Not Optional");
  2840. for (auto& argument : call.arguments)
  2841. argument.value->dump(indent + 2);
  2842. },
  2843. [&](ComputedReference const& ref) {
  2844. print_indent(indent + 1);
  2845. outln("ComputedReference({})", ref.mode == Mode::Optional ? "Optional" : "Not Optional");
  2846. ref.expression->dump(indent + 2);
  2847. },
  2848. [&](MemberReference const& ref) {
  2849. print_indent(indent + 1);
  2850. outln("MemberReference({})", ref.mode == Mode::Optional ? "Optional" : "Not Optional");
  2851. ref.identifier->dump(indent + 2);
  2852. },
  2853. [&](PrivateMemberReference const& ref) {
  2854. print_indent(indent + 1);
  2855. outln("PrivateMemberReference({})", ref.mode == Mode::Optional ? "Optional" : "Not Optional");
  2856. ref.private_identifier->dump(indent + 2);
  2857. });
  2858. }
  2859. }
  2860. ThrowCompletionOr<OptionalChain::ReferenceAndValue> OptionalChain::to_reference_and_value(Interpreter& interpreter) const
  2861. {
  2862. auto& vm = interpreter.vm();
  2863. auto base_reference = TRY(m_base->to_reference(interpreter));
  2864. auto base = base_reference.is_unresolvable()
  2865. ? TRY(m_base->execute(interpreter)).release_value()
  2866. : TRY(base_reference.get_value(vm));
  2867. for (auto& reference : m_references) {
  2868. auto is_optional = reference.visit([](auto& ref) { return ref.mode; }) == Mode::Optional;
  2869. if (is_optional && base.is_nullish())
  2870. return ReferenceAndValue { {}, js_undefined() };
  2871. auto expression = reference.visit(
  2872. [&](Call const& call) -> NonnullRefPtr<Expression const> {
  2873. return CallExpression::create(source_range(),
  2874. create_ast_node<SyntheticReferenceExpression>(source_range(), base_reference, base),
  2875. call.arguments, InvocationStyleEnum::Parenthesized, InsideParenthesesEnum::NotInsideParentheses);
  2876. },
  2877. [&](ComputedReference const& ref) -> NonnullRefPtr<Expression const> {
  2878. return create_ast_node<MemberExpression>(source_range(),
  2879. create_ast_node<SyntheticReferenceExpression>(source_range(), base_reference, base),
  2880. ref.expression,
  2881. true);
  2882. },
  2883. [&](MemberReference const& ref) -> NonnullRefPtr<Expression const> {
  2884. return create_ast_node<MemberExpression>(source_range(),
  2885. create_ast_node<SyntheticReferenceExpression>(source_range(), base_reference, base),
  2886. ref.identifier,
  2887. false);
  2888. },
  2889. [&](PrivateMemberReference const& ref) -> NonnullRefPtr<Expression const> {
  2890. return create_ast_node<MemberExpression>(source_range(),
  2891. create_ast_node<SyntheticReferenceExpression>(source_range(), base_reference, base),
  2892. ref.private_identifier,
  2893. false);
  2894. });
  2895. if (is<CallExpression>(*expression)) {
  2896. base_reference = JS::Reference {};
  2897. base = TRY(expression->execute(interpreter)).release_value();
  2898. } else {
  2899. base_reference = TRY(expression->to_reference(interpreter));
  2900. base = TRY(base_reference.get_value(vm));
  2901. }
  2902. }
  2903. return ReferenceAndValue { move(base_reference), base };
  2904. }
  2905. // 13.3.9.1 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-optional-chaining-evaluation
  2906. Completion OptionalChain::execute(Interpreter& interpreter) const
  2907. {
  2908. InterpreterNodeScope node_scope { interpreter, *this };
  2909. return TRY(to_reference_and_value(interpreter)).value;
  2910. }
  2911. ThrowCompletionOr<JS::Reference> OptionalChain::to_reference(Interpreter& interpreter) const
  2912. {
  2913. return TRY(to_reference_and_value(interpreter)).reference;
  2914. }
  2915. void MetaProperty::dump(int indent) const
  2916. {
  2917. DeprecatedString name;
  2918. if (m_type == MetaProperty::Type::NewTarget)
  2919. name = "new.target";
  2920. else if (m_type == MetaProperty::Type::ImportMeta)
  2921. name = "import.meta";
  2922. else
  2923. VERIFY_NOT_REACHED();
  2924. print_indent(indent);
  2925. outln("{} {}", class_name(), name);
  2926. }
  2927. // 13.3.12.1 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-meta-properties-runtime-semantics-evaluation
  2928. Completion MetaProperty::execute(Interpreter& interpreter) const
  2929. {
  2930. InterpreterNodeScope node_scope { interpreter, *this };
  2931. auto& vm = interpreter.vm();
  2932. // NewTarget : new . target
  2933. if (m_type == MetaProperty::Type::NewTarget) {
  2934. // 1. Return GetNewTarget().
  2935. return interpreter.vm().get_new_target();
  2936. }
  2937. // ImportMeta : import . meta
  2938. if (m_type == MetaProperty::Type::ImportMeta) {
  2939. return Value(vm.get_import_meta());
  2940. }
  2941. VERIFY_NOT_REACHED();
  2942. }
  2943. void ImportCall::dump(int indent) const
  2944. {
  2945. ASTNode::dump(indent);
  2946. print_indent(indent);
  2947. outln("(Specifier)");
  2948. m_specifier->dump(indent + 1);
  2949. if (m_options) {
  2950. outln("(Options)");
  2951. m_options->dump(indent + 1);
  2952. }
  2953. }
  2954. // 13.3.10.1 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-import-call-runtime-semantics-evaluation
  2955. // Also includes assertions from proposal: https://tc39.es/proposal-import-assertions/#sec-import-call-runtime-semantics-evaluation
  2956. Completion ImportCall::execute(Interpreter& interpreter) const
  2957. {
  2958. InterpreterNodeScope node_scope { interpreter, *this };
  2959. auto& vm = interpreter.vm();
  2960. // 2. Let specifierRef be the result of evaluating specifierExpression.
  2961. // 3. Let specifier be ? GetValue(specifierRef).
  2962. auto specifier = TRY(m_specifier->execute(interpreter));
  2963. auto options_value = js_undefined();
  2964. // 4. If optionsExpression is present, then
  2965. if (m_options) {
  2966. // a. Let optionsRef be the result of evaluating optionsExpression.
  2967. // b. Let options be ? GetValue(optionsRef).
  2968. options_value = TRY(m_options->execute(interpreter)).release_value();
  2969. }
  2970. // 5. Else,
  2971. // a. Let options be undefined.
  2972. // Note: options_value is undefined by default.
  2973. return perform_import_call(vm, *specifier, options_value);
  2974. }
  2975. // 13.2.3.1 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-literals-runtime-semantics-evaluation
  2976. Completion StringLiteral::execute(Interpreter& interpreter) const
  2977. {
  2978. InterpreterNodeScope node_scope { interpreter, *this };
  2979. auto& vm = interpreter.vm();
  2980. // 1. Return the SV of StringLiteral as defined in 12.8.4.2.
  2981. return Value { PrimitiveString::create(vm, m_value) };
  2982. }
  2983. // 13.2.3.1 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-literals-runtime-semantics-evaluation
  2984. Completion NumericLiteral::execute(Interpreter& interpreter) const
  2985. {
  2986. InterpreterNodeScope node_scope { interpreter, *this };
  2987. // 1. Return the NumericValue of NumericLiteral as defined in 12.8.3.
  2988. return Value(m_value);
  2989. }
  2990. // 13.2.3.1 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-literals-runtime-semantics-evaluation
  2991. Completion BigIntLiteral::execute(Interpreter& interpreter) const
  2992. {
  2993. InterpreterNodeScope node_scope { interpreter, *this };
  2994. auto& vm = interpreter.vm();
  2995. // 1. Return the NumericValue of NumericLiteral as defined in 12.8.3.
  2996. Crypto::SignedBigInteger integer;
  2997. if (m_value[0] == '0' && m_value.length() >= 3) {
  2998. if (m_value[1] == 'x' || m_value[1] == 'X') {
  2999. return Value { BigInt::create(vm, Crypto::SignedBigInteger::from_base(16, m_value.substring(2, m_value.length() - 3))) };
  3000. } else if (m_value[1] == 'o' || m_value[1] == 'O') {
  3001. return Value { BigInt::create(vm, Crypto::SignedBigInteger::from_base(8, m_value.substring(2, m_value.length() - 3))) };
  3002. } else if (m_value[1] == 'b' || m_value[1] == 'B') {
  3003. return Value { BigInt::create(vm, Crypto::SignedBigInteger::from_base(2, m_value.substring(2, m_value.length() - 3))) };
  3004. }
  3005. }
  3006. return Value { BigInt::create(vm, Crypto::SignedBigInteger::from_base(10, m_value.substring(0, m_value.length() - 1))) };
  3007. }
  3008. // 13.2.3.1 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-literals-runtime-semantics-evaluation
  3009. Completion BooleanLiteral::execute(Interpreter& interpreter) const
  3010. {
  3011. InterpreterNodeScope node_scope { interpreter, *this };
  3012. // 1. If BooleanLiteral is the token false, return false.
  3013. // 2. If BooleanLiteral is the token true, return true.
  3014. return Value(m_value);
  3015. }
  3016. // 13.2.3.1 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-literals-runtime-semantics-evaluation
  3017. Completion NullLiteral::execute(Interpreter& interpreter) const
  3018. {
  3019. InterpreterNodeScope node_scope { interpreter, *this };
  3020. // 1. Return null.
  3021. return js_null();
  3022. }
  3023. void RegExpLiteral::dump(int indent) const
  3024. {
  3025. print_indent(indent);
  3026. outln("{} (/{}/{})", class_name(), pattern(), flags());
  3027. }
  3028. // 13.2.7.3 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-regular-expression-literals-runtime-semantics-evaluation
  3029. Completion RegExpLiteral::execute(Interpreter& interpreter) const
  3030. {
  3031. InterpreterNodeScope node_scope { interpreter, *this };
  3032. auto& vm = interpreter.vm();
  3033. auto& realm = *vm.current_realm();
  3034. // 1. Let pattern be CodePointsToString(BodyText of RegularExpressionLiteral).
  3035. auto pattern = this->pattern();
  3036. // 2. Let flags be CodePointsToString(FlagText of RegularExpressionLiteral).
  3037. auto flags = this->flags();
  3038. // 3. Return ! RegExpCreate(pattern, flags).
  3039. Regex<ECMA262> regex(parsed_regex(), parsed_pattern(), parsed_flags());
  3040. // NOTE: We bypass RegExpCreate and subsequently RegExpAlloc as an optimization to use the already parsed values.
  3041. auto regexp_object = RegExpObject::create(realm, move(regex), move(pattern), move(flags));
  3042. // RegExpAlloc has these two steps from the 'Legacy RegExp features' proposal.
  3043. regexp_object->set_realm(*vm.current_realm());
  3044. // We don't need to check 'If SameValue(newTarget, thisRealm.[[Intrinsics]].[[%RegExp%]]) is true'
  3045. // here as we know RegExpCreate calls RegExpAlloc with %RegExp% for newTarget.
  3046. regexp_object->set_legacy_features_enabled(true);
  3047. return Value { regexp_object };
  3048. }
  3049. void ArrayExpression::dump(int indent) const
  3050. {
  3051. ASTNode::dump(indent);
  3052. for (auto& element : m_elements) {
  3053. if (element) {
  3054. element->dump(indent + 1);
  3055. } else {
  3056. print_indent(indent + 1);
  3057. outln("<empty>");
  3058. }
  3059. }
  3060. }
  3061. // 13.2.4.2 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-array-initializer-runtime-semantics-evaluation
  3062. Completion ArrayExpression::execute(Interpreter& interpreter) const
  3063. {
  3064. InterpreterNodeScope node_scope { interpreter, *this };
  3065. auto& vm = interpreter.vm();
  3066. auto& realm = *vm.current_realm();
  3067. // 1. Let array be ! ArrayCreate(0).
  3068. auto array = MUST(Array::create(realm, 0));
  3069. // 2. Perform ? ArrayAccumulation of ElementList with arguments array and 0.
  3070. array->indexed_properties();
  3071. size_t index = 0;
  3072. for (auto& element : m_elements) {
  3073. auto value = Value();
  3074. if (element) {
  3075. value = TRY(element->execute(interpreter)).release_value();
  3076. if (is<SpreadExpression>(*element)) {
  3077. (void)TRY(get_iterator_values(vm, value, [&](Value iterator_value) -> Optional<Completion> {
  3078. array->indexed_properties().put(index++, iterator_value, default_attributes);
  3079. return {};
  3080. }));
  3081. continue;
  3082. }
  3083. }
  3084. array->indexed_properties().put(index++, value, default_attributes);
  3085. }
  3086. // 3. Return array.
  3087. return Value { array };
  3088. }
  3089. void TemplateLiteral::dump(int indent) const
  3090. {
  3091. ASTNode::dump(indent);
  3092. for (auto& expression : m_expressions)
  3093. expression->dump(indent + 1);
  3094. }
  3095. // 13.2.8.5 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-template-literals-runtime-semantics-evaluation
  3096. Completion TemplateLiteral::execute(Interpreter& interpreter) const
  3097. {
  3098. InterpreterNodeScope node_scope { interpreter, *this };
  3099. auto& vm = interpreter.vm();
  3100. StringBuilder string_builder;
  3101. for (auto& expression : m_expressions) {
  3102. // 1. Let head be the TV of TemplateHead as defined in 12.8.6.
  3103. // 2. Let subRef be the result of evaluating Expression.
  3104. // 3. Let sub be ? GetValue(subRef).
  3105. auto sub = TRY(expression->execute(interpreter)).release_value();
  3106. // 4. Let middle be ? ToString(sub).
  3107. auto string = TRY(sub.to_deprecated_string(vm));
  3108. string_builder.append(string);
  3109. // 5. Let tail be the result of evaluating TemplateSpans.
  3110. // 6. ReturnIfAbrupt(tail).
  3111. }
  3112. // 7. Return the string-concatenation of head, middle, and tail.
  3113. return Value { PrimitiveString::create(vm, string_builder.to_deprecated_string()) };
  3114. }
  3115. void TaggedTemplateLiteral::dump(int indent) const
  3116. {
  3117. ASTNode::dump(indent);
  3118. print_indent(indent + 1);
  3119. outln("(Tag)");
  3120. m_tag->dump(indent + 2);
  3121. print_indent(indent + 1);
  3122. outln("(Template Literal)");
  3123. m_template_literal->dump(indent + 2);
  3124. }
  3125. // 13.3.11.1 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-tagged-templates-runtime-semantics-evaluation
  3126. Completion TaggedTemplateLiteral::execute(Interpreter& interpreter) const
  3127. {
  3128. InterpreterNodeScope node_scope { interpreter, *this };
  3129. auto& vm = interpreter.vm();
  3130. // NOTE: This is both
  3131. // MemberExpression : MemberExpression TemplateLiteral
  3132. // CallExpression : CallExpression TemplateLiteral
  3133. // 1. Let tagRef be ? Evaluation of MemberExpression.
  3134. // 1. Let tagRef be ? Evaluation of CallExpression.
  3135. // 2. Let tagFunc be ? GetValue(tagRef).
  3136. // NOTE: This is much more complicated than the spec because we have to
  3137. // handle every type of reference. If we handle evaluation closer
  3138. // to the spec this could be improved.
  3139. Value tag_this_value;
  3140. Value tag;
  3141. if (auto tag_reference = TRY(m_tag->to_reference(interpreter)); tag_reference.is_valid_reference()) {
  3142. tag = TRY(tag_reference.get_value(vm));
  3143. if (tag_reference.is_environment_reference()) {
  3144. auto& environment = tag_reference.base_environment();
  3145. if (environment.has_this_binding())
  3146. tag_this_value = TRY(environment.get_this_binding(vm));
  3147. else
  3148. tag_this_value = js_undefined();
  3149. } else {
  3150. tag_this_value = tag_reference.get_this_value();
  3151. }
  3152. } else {
  3153. auto result = TRY(m_tag->execute(interpreter));
  3154. VERIFY(result.has_value());
  3155. tag = result.release_value();
  3156. tag_this_value = js_undefined();
  3157. }
  3158. // 3. Let thisCall be this CallExpression.
  3159. // 3. Let thisCall be this MemberExpression.
  3160. // FIXME: 4. Let tailCall be IsInTailPosition(thisCall).
  3161. // NOTE: A tagged template is a function call where the arguments of the call are derived from a
  3162. // TemplateLiteral (13.2.8). The actual arguments include a template object (13.2.8.3)
  3163. // and the values produced by evaluating the expressions embedded within the TemplateLiteral.
  3164. auto template_ = TRY(get_template_object(interpreter));
  3165. MarkedVector<Value> arguments(interpreter.vm().heap());
  3166. arguments.append(template_);
  3167. auto& expressions = m_template_literal->expressions();
  3168. // tag`${foo}` -> "", foo, "" -> tag(["", ""], foo)
  3169. // tag`foo${bar}baz${qux}` -> "foo", bar, "baz", qux, "" -> tag(["foo", "baz", ""], bar, qux)
  3170. // So we want all the odd expressions
  3171. for (size_t i = 1; i < expressions.size(); i += 2)
  3172. arguments.append(TRY(expressions[i]->execute(interpreter)).release_value());
  3173. // 5. Return ? EvaluateCall(tagFunc, tagRef, TemplateLiteral, tailCall).
  3174. return call(vm, tag, tag_this_value, move(arguments));
  3175. }
  3176. // 13.2.8.3 GetTemplateObject ( templateLiteral ), https://tc39.es/ecma262/#sec-gettemplateobject
  3177. ThrowCompletionOr<Value> TaggedTemplateLiteral::get_template_object(Interpreter& interpreter) const
  3178. {
  3179. auto& vm = interpreter.vm();
  3180. // 1. Let realm be the current Realm Record.
  3181. auto& realm = *vm.current_realm();
  3182. // 2. Let templateRegistry be realm.[[TemplateMap]].
  3183. // 3. For each element e of templateRegistry, do
  3184. // a. If e.[[Site]] is the same Parse Node as templateLiteral, then
  3185. // i. Return e.[[Array]].
  3186. // NOTE: Instead of caching on the realm we cache on the Parse Node side as
  3187. // this makes it easier to track whether it is the same parse node.
  3188. if (auto cached_value_or_end = m_cached_values.find(&realm); cached_value_or_end != m_cached_values.end())
  3189. return Value { cached_value_or_end->value.cell() };
  3190. // 4. Let rawStrings be TemplateStrings of templateLiteral with argument true.
  3191. auto& raw_strings = m_template_literal->raw_strings();
  3192. // 5. Let cookedStrings be TemplateStrings of templateLiteral with argument false.
  3193. auto& expressions = m_template_literal->expressions();
  3194. // 6. Let count be the number of elements in the List cookedStrings.
  3195. // NOTE: Only the even expression in expression are the cooked strings
  3196. // so we use rawStrings for the size here
  3197. VERIFY(raw_strings.size() == (expressions.size() + 1) / 2);
  3198. auto count = raw_strings.size();
  3199. // 7. Assert: count ≤ 2^32 - 1.
  3200. VERIFY(count <= 0xffffffff);
  3201. // 8. Let template be ! ArrayCreate(count).
  3202. // NOTE: We don't set count since we push the values using append which
  3203. // would then append after count. Same for 9.
  3204. auto template_ = MUST(Array::create(realm, 0));
  3205. // 9. Let rawObj be ! ArrayCreate(count).
  3206. auto raw_obj = MUST(Array::create(realm, 0));
  3207. // 10. Let index be 0.
  3208. // 11. Repeat, while index < count,
  3209. for (size_t i = 0; i < count; ++i) {
  3210. auto cooked_string_index = i * 2;
  3211. // a. Let prop be ! ToString(𝔽(index)).
  3212. // b. Let cookedValue be cookedStrings[index].
  3213. auto cooked_value = TRY(expressions[cooked_string_index]->execute(interpreter)).release_value();
  3214. // NOTE: If the string contains invalid escapes we get a null expression here,
  3215. // which we then convert to the expected `undefined` TV. See
  3216. // 12.9.6.1 Static Semantics: TV, https://tc39.es/ecma262/#sec-static-semantics-tv
  3217. if (cooked_value.is_null())
  3218. cooked_value = js_undefined();
  3219. // c. Perform ! DefinePropertyOrThrow(template, prop, PropertyDescriptor { [[Value]]: cookedValue, [[Writable]]: false, [[Enumerable]]: true, [[Configurable]]: false }).
  3220. template_->indexed_properties().append(cooked_value);
  3221. // d. Let rawValue be the String value rawStrings[index].
  3222. // e. Perform ! DefinePropertyOrThrow(rawObj, prop, PropertyDescriptor { [[Value]]: rawValue, [[Writable]]: false, [[Enumerable]]: true, [[Configurable]]: false }).
  3223. raw_obj->indexed_properties().append(TRY(raw_strings[i]->execute(interpreter)).release_value());
  3224. // f. Set index to index + 1.
  3225. }
  3226. // 12. Perform ! SetIntegrityLevel(rawObj, frozen).
  3227. MUST(raw_obj->set_integrity_level(Object::IntegrityLevel::Frozen));
  3228. // 13. Perform ! DefinePropertyOrThrow(template, "raw", PropertyDescriptor { [[Value]]: rawObj, [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }).
  3229. template_->define_direct_property(interpreter.vm().names.raw, raw_obj, 0);
  3230. // 14. Perform ! SetIntegrityLevel(template, frozen).
  3231. MUST(template_->set_integrity_level(Object::IntegrityLevel::Frozen));
  3232. // 15. Append the Record { [[Site]]: templateLiteral, [[Array]]: template } to templateRegistry.
  3233. m_cached_values.set(&realm, make_handle(template_));
  3234. // 16. Return template.
  3235. return template_;
  3236. }
  3237. void TryStatement::dump(int indent) const
  3238. {
  3239. ASTNode::dump(indent);
  3240. print_indent(indent);
  3241. outln("(Block)");
  3242. block().dump(indent + 1);
  3243. if (handler()) {
  3244. print_indent(indent);
  3245. outln("(Handler)");
  3246. handler()->dump(indent + 1);
  3247. }
  3248. if (finalizer()) {
  3249. print_indent(indent);
  3250. outln("(Finalizer)");
  3251. finalizer()->dump(indent + 1);
  3252. }
  3253. }
  3254. void CatchClause::dump(int indent) const
  3255. {
  3256. print_indent(indent);
  3257. m_parameter.visit(
  3258. [&](DeprecatedFlyString const& parameter) {
  3259. if (parameter.is_null())
  3260. outln("CatchClause");
  3261. else
  3262. outln("CatchClause ({})", parameter);
  3263. },
  3264. [&](NonnullRefPtr<BindingPattern const> const& pattern) {
  3265. outln("CatchClause");
  3266. print_indent(indent);
  3267. outln("(Parameter)");
  3268. pattern->dump(indent + 2);
  3269. });
  3270. body().dump(indent + 1);
  3271. }
  3272. void ThrowStatement::dump(int indent) const
  3273. {
  3274. ASTNode::dump(indent);
  3275. argument().dump(indent + 1);
  3276. }
  3277. // 14.15.3 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-try-statement-runtime-semantics-evaluation
  3278. Completion TryStatement::execute(Interpreter& interpreter) const
  3279. {
  3280. InterpreterNodeScope node_scope { interpreter, *this };
  3281. auto& vm = interpreter.vm();
  3282. // 14.15.2 Runtime Semantics: CatchClauseEvaluation, https://tc39.es/ecma262/#sec-runtime-semantics-catchclauseevaluation
  3283. auto catch_clause_evaluation = [&](Value thrown_value) {
  3284. // 1. Let oldEnv be the running execution context's LexicalEnvironment.
  3285. auto old_environment = vm.running_execution_context().lexical_environment;
  3286. // 2. Let catchEnv be NewDeclarativeEnvironment(oldEnv).
  3287. auto catch_environment = new_declarative_environment(*old_environment);
  3288. m_handler->parameter().visit(
  3289. [&](DeprecatedFlyString const& parameter) {
  3290. // 3. For each element argName of the BoundNames of CatchParameter, do
  3291. // a. Perform ! catchEnv.CreateMutableBinding(argName, false).
  3292. MUST(catch_environment->create_mutable_binding(vm, parameter, false));
  3293. },
  3294. [&](NonnullRefPtr<BindingPattern const> const& pattern) {
  3295. // 3. For each element argName of the BoundNames of CatchParameter, do
  3296. // NOTE: Due to the use of MUST with `create_mutable_binding` below, an exception should not result from `for_each_bound_name`.
  3297. MUST(pattern->for_each_bound_identifier([&](auto& identifier) {
  3298. // a. Perform ! catchEnv.CreateMutableBinding(argName, false).
  3299. MUST(catch_environment->create_mutable_binding(vm, identifier.string(), false));
  3300. }));
  3301. });
  3302. // 4. Set the running execution context's LexicalEnvironment to catchEnv.
  3303. vm.running_execution_context().lexical_environment = catch_environment;
  3304. // 5. Let status be Completion(BindingInitialization of CatchParameter with arguments thrownValue and catchEnv).
  3305. auto status = m_handler->parameter().visit(
  3306. [&](DeprecatedFlyString const& parameter) {
  3307. return catch_environment->initialize_binding(vm, parameter, thrown_value, Environment::InitializeBindingHint::Normal);
  3308. },
  3309. [&](NonnullRefPtr<BindingPattern const> const& pattern) {
  3310. return vm.binding_initialization(pattern, thrown_value, catch_environment);
  3311. });
  3312. // 6. If status is an abrupt completion, then
  3313. if (status.is_error()) {
  3314. // a. Set the running execution context's LexicalEnvironment to oldEnv.
  3315. vm.running_execution_context().lexical_environment = old_environment;
  3316. // b. Return ? status.
  3317. return status.release_error();
  3318. }
  3319. // 7. Let B be the result of evaluating Block.
  3320. auto handler_result = m_handler->body().execute(interpreter);
  3321. // 8. Set the running execution context's LexicalEnvironment to oldEnv.
  3322. vm.running_execution_context().lexical_environment = old_environment;
  3323. // 9. Return ? B.
  3324. return handler_result;
  3325. };
  3326. Completion result;
  3327. // 1. Let B be the result of evaluating Block.
  3328. auto block_result = m_block->execute(interpreter);
  3329. // TryStatement : try Block Catch
  3330. // TryStatement : try Block Catch Finally
  3331. if (m_handler) {
  3332. // 2. If B.[[Type]] is throw, let C be Completion(CatchClauseEvaluation of Catch with argument B.[[Value]]).
  3333. if (block_result.type() == Completion::Type::Throw)
  3334. result = catch_clause_evaluation(*block_result.value());
  3335. // 3. Else, let C be B.
  3336. else
  3337. result = move(block_result);
  3338. } else {
  3339. // TryStatement : try Block Finally
  3340. // This variant doesn't have C & uses B in the finalizer step.
  3341. result = move(block_result);
  3342. }
  3343. // TryStatement : try Block Finally
  3344. // TryStatement : try Block Catch Finally
  3345. if (m_finalizer) {
  3346. // 4. Let F be the result of evaluating Finally.
  3347. auto finalizer_result = m_finalizer->execute(interpreter);
  3348. // 5. If F.[[Type]] is normal, set F to C.
  3349. if (finalizer_result.type() == Completion::Type::Normal)
  3350. finalizer_result = move(result);
  3351. // 6. Return ? UpdateEmpty(F, undefined).
  3352. return finalizer_result.update_empty(js_undefined());
  3353. }
  3354. // 4. Return ? UpdateEmpty(C, undefined).
  3355. return result.update_empty(js_undefined());
  3356. }
  3357. Completion CatchClause::execute(Interpreter& interpreter) const
  3358. {
  3359. InterpreterNodeScope node_scope { interpreter, *this };
  3360. // NOTE: CatchClause execution is handled by TryStatement.
  3361. VERIFY_NOT_REACHED();
  3362. return {};
  3363. }
  3364. // 14.14.1 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-throw-statement-runtime-semantics-evaluation
  3365. Completion ThrowStatement::execute(Interpreter& interpreter) const
  3366. {
  3367. InterpreterNodeScope node_scope { interpreter, *this };
  3368. // 1. Let exprRef be the result of evaluating Expression.
  3369. // 2. Let exprValue be ? GetValue(exprRef).
  3370. auto value = TRY(m_argument->execute(interpreter)).release_value();
  3371. // 3. Return ThrowCompletion(exprValue).
  3372. return throw_completion(value);
  3373. }
  3374. // 14.1.1 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-statement-semantics-runtime-semantics-evaluation
  3375. // BreakableStatement : SwitchStatement
  3376. Completion SwitchStatement::execute(Interpreter& interpreter) const
  3377. {
  3378. // 1. Let newLabelSet be a new empty List.
  3379. // 2. Return ? LabelledEvaluation of this BreakableStatement with argument newLabelSet.
  3380. return labelled_evaluation(interpreter, *this, {});
  3381. }
  3382. // NOTE: Since we don't have the 'BreakableStatement' from the spec as a separate ASTNode that wraps IterationStatement / SwitchStatement,
  3383. // execute() needs to take care of LabelledEvaluation, which in turn calls execute_impl().
  3384. // 14.12.4 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-switch-statement-runtime-semantics-evaluation
  3385. Completion SwitchStatement::execute_impl(Interpreter& interpreter) const
  3386. {
  3387. InterpreterNodeScope node_scope { interpreter, *this };
  3388. auto& vm = interpreter.vm();
  3389. // 14.12.3 CaseClauseIsSelected ( C, input ), https://tc39.es/ecma262/#sec-runtime-semantics-caseclauseisselected
  3390. auto case_clause_is_selected = [&](auto const& case_clause, auto input) -> ThrowCompletionOr<bool> {
  3391. // 1. Assert: C is an instance of the production CaseClause : case Expression : StatementList[opt] .
  3392. VERIFY(case_clause->test());
  3393. // 2. Let exprRef be the result of evaluating the Expression of C.
  3394. // 3. Let clauseSelector be ? GetValue(exprRef).
  3395. auto clause_selector = TRY(case_clause->test()->execute(interpreter)).release_value();
  3396. // 4. Return IsStrictlyEqual(input, clauseSelector).
  3397. return is_strictly_equal(input, clause_selector);
  3398. };
  3399. // 14.12.2 Runtime Semantics: CaseBlockEvaluation, https://tc39.es/ecma262/#sec-runtime-semantics-caseblockevaluation
  3400. auto case_block_evaluation = [&](auto input) -> Completion {
  3401. // CaseBlock : { }
  3402. if (m_cases.is_empty()) {
  3403. // 1. Return undefined.
  3404. return js_undefined();
  3405. }
  3406. Vector<NonnullRefPtr<SwitchCase const>> case_clauses_1;
  3407. Vector<NonnullRefPtr<SwitchCase const>> case_clauses_2;
  3408. RefPtr<SwitchCase const> default_clause;
  3409. for (auto const& switch_case : m_cases) {
  3410. if (!switch_case->test())
  3411. default_clause = switch_case;
  3412. else if (!default_clause)
  3413. case_clauses_1.append(switch_case);
  3414. else
  3415. case_clauses_2.append(switch_case);
  3416. }
  3417. // CaseBlock : { CaseClauses }
  3418. if (!default_clause) {
  3419. VERIFY(!case_clauses_1.is_empty());
  3420. VERIFY(case_clauses_2.is_empty());
  3421. // 1. Let V be undefined.
  3422. auto last_value = js_undefined();
  3423. // 2. Let A be the List of CaseClause items in CaseClauses, in source text order.
  3424. // NOTE: A is case_clauses_1.
  3425. // 3. Let found be false.
  3426. auto found = false;
  3427. // 4. For each CaseClause C of A, do
  3428. for (auto const& case_clause : case_clauses_1) {
  3429. // a. If found is false, then
  3430. if (!found) {
  3431. // i. Set found to ? CaseClauseIsSelected(C, input).
  3432. found = TRY(case_clause_is_selected(case_clause, input));
  3433. }
  3434. // b. If found is true, then
  3435. if (found) {
  3436. // i. Let R be the result of evaluating C.
  3437. auto result = case_clause->evaluate_statements(interpreter);
  3438. // ii. If R.[[Value]] is not empty, set V to R.[[Value]].
  3439. if (result.value().has_value())
  3440. last_value = *result.value();
  3441. // iii. If R is an abrupt completion, return ? UpdateEmpty(R, V).
  3442. if (result.is_abrupt())
  3443. return result.update_empty(last_value);
  3444. }
  3445. }
  3446. // 5. Return V.
  3447. return last_value;
  3448. }
  3449. // CaseBlock : { CaseClauses[opt] DefaultClause CaseClauses[opt] }
  3450. else {
  3451. // 1. Let V be undefined.
  3452. auto last_value = js_undefined();
  3453. // 2. If the first CaseClauses is present, then
  3454. // a. Let A be the List of CaseClause items in the first CaseClauses, in source text order.
  3455. // 3. Else,
  3456. // a. Let A be a new empty List.
  3457. // NOTE: A is case_clauses_1.
  3458. // 4. Let found be false.
  3459. auto found = false;
  3460. // 5. For each CaseClause C of A, do
  3461. for (auto const& case_clause : case_clauses_1) {
  3462. // a. If found is false, then
  3463. if (!found) {
  3464. // i. Set found to ? CaseClauseIsSelected(C, input).
  3465. found = TRY(case_clause_is_selected(case_clause, input));
  3466. }
  3467. // b. If found is true, then
  3468. if (found) {
  3469. // i. Let R be the result of evaluating C.
  3470. auto result = case_clause->evaluate_statements(interpreter);
  3471. // ii. If R.[[Value]] is not empty, set V to R.[[Value]].
  3472. if (result.value().has_value())
  3473. last_value = *result.value();
  3474. // iii. If R is an abrupt completion, return ? UpdateEmpty(R, V).
  3475. if (result.is_abrupt())
  3476. return result.update_empty(last_value);
  3477. }
  3478. }
  3479. // 6. Let foundInB be false.
  3480. auto found_in_b = false;
  3481. // 7. If the second CaseClauses is present, then
  3482. // a. Let B be the List of CaseClause items in the second CaseClauses, in source text order.
  3483. // 8. Else,
  3484. // a. Let B be a new empty List.
  3485. // NOTE: B is case_clauses_2.
  3486. // 9. If found is false, then
  3487. if (!found) {
  3488. // a. For each CaseClause C of B, do
  3489. for (auto const& case_clause : case_clauses_2) {
  3490. // i. If foundInB is false, then
  3491. if (!found_in_b) {
  3492. // 1. Set foundInB to ? CaseClauseIsSelected(C, input).
  3493. found_in_b = TRY(case_clause_is_selected(case_clause, input));
  3494. }
  3495. // ii. If foundInB is true, then
  3496. if (found_in_b) {
  3497. // 1. Let R be the result of evaluating CaseClause C.
  3498. auto result = case_clause->evaluate_statements(interpreter);
  3499. // 2. If R.[[Value]] is not empty, set V to R.[[Value]].
  3500. if (result.value().has_value())
  3501. last_value = *result.value();
  3502. // 3. If R is an abrupt completion, return ? UpdateEmpty(R, V).
  3503. if (result.is_abrupt())
  3504. return result.update_empty(last_value);
  3505. }
  3506. }
  3507. }
  3508. // 10. If foundInB is true, return V.
  3509. if (found_in_b)
  3510. return last_value;
  3511. // 11. Let R be the result of evaluating DefaultClause.
  3512. auto result = default_clause->evaluate_statements(interpreter);
  3513. // 12. If R.[[Value]] is not empty, set V to R.[[Value]].
  3514. if (result.value().has_value())
  3515. last_value = *result.value();
  3516. // 13. If R is an abrupt completion, return ? UpdateEmpty(R, V).
  3517. if (result.is_abrupt())
  3518. return result.update_empty(last_value);
  3519. // 14. NOTE: The following is another complete iteration of the second CaseClauses.
  3520. // 15. For each CaseClause C of B, do
  3521. for (auto const& case_clause : case_clauses_2) {
  3522. // a. Let R be the result of evaluating CaseClause C.
  3523. result = case_clause->evaluate_statements(interpreter);
  3524. // b. If R.[[Value]] is not empty, set V to R.[[Value]].
  3525. if (result.value().has_value())
  3526. last_value = *result.value();
  3527. // c. If R is an abrupt completion, return ? UpdateEmpty(R, V).
  3528. if (result.is_abrupt())
  3529. return result.update_empty(last_value);
  3530. }
  3531. // 16. Return V.
  3532. return last_value;
  3533. }
  3534. VERIFY_NOT_REACHED();
  3535. };
  3536. // SwitchStatement : switch ( Expression ) CaseBlock
  3537. // 1. Let exprRef be the result of evaluating Expression.
  3538. // 2. Let switchValue be ? GetValue(exprRef).
  3539. auto switch_value = TRY(m_discriminant->execute(interpreter)).release_value();
  3540. Completion result;
  3541. // Optimization: Avoid creating a lexical environment if there are no lexical declarations.
  3542. if (has_lexical_declarations()) {
  3543. // 3. Let oldEnv be the running execution context's LexicalEnvironment.
  3544. auto* old_environment = interpreter.lexical_environment();
  3545. // 4. Let blockEnv be NewDeclarativeEnvironment(oldEnv).
  3546. auto block_environment = new_declarative_environment(*old_environment);
  3547. // 5. Perform BlockDeclarationInstantiation(CaseBlock, blockEnv).
  3548. block_declaration_instantiation(vm, block_environment);
  3549. // 6. Set the running execution context's LexicalEnvironment to blockEnv.
  3550. vm.running_execution_context().lexical_environment = block_environment;
  3551. // 7. Let R be Completion(CaseBlockEvaluation of CaseBlock with argument switchValue).
  3552. result = case_block_evaluation(switch_value);
  3553. // 8. Let env be blockEnv's LexicalEnvironment.
  3554. // FIXME: blockEnv doesn't have a lexical env it is one?? Probably a spec issue
  3555. // 9. Set R to DisposeResources(env, R).
  3556. result = dispose_resources(vm, block_environment, result);
  3557. // 10. Set the running execution context's LexicalEnvironment to oldEnv.
  3558. vm.running_execution_context().lexical_environment = old_environment;
  3559. } else {
  3560. result = case_block_evaluation(switch_value);
  3561. }
  3562. // 11. Return R.
  3563. return result;
  3564. }
  3565. Completion SwitchCase::execute(Interpreter& interpreter) const
  3566. {
  3567. InterpreterNodeScope node_scope { interpreter, *this };
  3568. // NOTE: SwitchCase execution is handled by SwitchStatement.
  3569. VERIFY_NOT_REACHED();
  3570. return {};
  3571. }
  3572. // 14.9.2 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-break-statement-runtime-semantics-evaluation
  3573. Completion BreakStatement::execute(Interpreter& interpreter) const
  3574. {
  3575. InterpreterNodeScope node_scope { interpreter, *this };
  3576. // BreakStatement : break ;
  3577. if (m_target_label.is_null()) {
  3578. // 1. Return Completion Record { [[Type]]: break, [[Value]]: empty, [[Target]]: empty }.
  3579. return { Completion::Type::Break, {}, {} };
  3580. }
  3581. // BreakStatement : break LabelIdentifier ;
  3582. // 1. Let label be the StringValue of LabelIdentifier.
  3583. // 2. Return Completion Record { [[Type]]: break, [[Value]]: empty, [[Target]]: label }.
  3584. return { Completion::Type::Break, {}, m_target_label };
  3585. }
  3586. // 14.8.2 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-continue-statement-runtime-semantics-evaluation
  3587. Completion ContinueStatement::execute(Interpreter& interpreter) const
  3588. {
  3589. InterpreterNodeScope node_scope { interpreter, *this };
  3590. // ContinueStatement : continue ;
  3591. if (m_target_label.is_null()) {
  3592. // 1. Return Completion Record { [[Type]]: continue, [[Value]]: empty, [[Target]]: empty }.
  3593. return { Completion::Type::Continue, {}, {} };
  3594. }
  3595. // ContinueStatement : continue LabelIdentifier ;
  3596. // 1. Let label be the StringValue of LabelIdentifier.
  3597. // 2. Return Completion Record { [[Type]]: continue, [[Value]]: empty, [[Target]]: label }.
  3598. return { Completion::Type::Continue, {}, m_target_label };
  3599. }
  3600. void SwitchStatement::dump(int indent) const
  3601. {
  3602. ASTNode::dump(indent);
  3603. m_discriminant->dump(indent + 1);
  3604. for (auto& switch_case : m_cases) {
  3605. switch_case->dump(indent + 1);
  3606. }
  3607. }
  3608. void SwitchCase::dump(int indent) const
  3609. {
  3610. print_indent(indent + 1);
  3611. if (m_test) {
  3612. outln("(Test)");
  3613. m_test->dump(indent + 2);
  3614. } else {
  3615. outln("(Default)");
  3616. }
  3617. print_indent(indent + 1);
  3618. outln("(Consequent)");
  3619. ScopeNode::dump(indent + 2);
  3620. }
  3621. // 13.14.1 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-conditional-operator-runtime-semantics-evaluation
  3622. Completion ConditionalExpression::execute(Interpreter& interpreter) const
  3623. {
  3624. InterpreterNodeScope node_scope { interpreter, *this };
  3625. // 1. Let lref be the result of evaluating ShortCircuitExpression.
  3626. // 2. Let lval be ToBoolean(? GetValue(lref)).
  3627. auto test_result = TRY(m_test->execute(interpreter)).release_value();
  3628. // 3. If lval is true, then
  3629. if (test_result.to_boolean()) {
  3630. // a. Let trueRef be the result of evaluating the first AssignmentExpression.
  3631. // b. Return ? GetValue(trueRef).
  3632. return m_consequent->execute(interpreter);
  3633. }
  3634. // 4. Else,
  3635. else {
  3636. // a. Let falseRef be the result of evaluating the second AssignmentExpression.
  3637. // b. Return ? GetValue(falseRef).
  3638. return m_alternate->execute(interpreter);
  3639. }
  3640. }
  3641. void ConditionalExpression::dump(int indent) const
  3642. {
  3643. ASTNode::dump(indent);
  3644. print_indent(indent + 1);
  3645. outln("(Test)");
  3646. m_test->dump(indent + 2);
  3647. print_indent(indent + 1);
  3648. outln("(Consequent)");
  3649. m_consequent->dump(indent + 2);
  3650. print_indent(indent + 1);
  3651. outln("(Alternate)");
  3652. m_alternate->dump(indent + 2);
  3653. }
  3654. void SequenceExpression::dump(int indent) const
  3655. {
  3656. ASTNode::dump(indent);
  3657. for (auto& expression : m_expressions)
  3658. expression->dump(indent + 1);
  3659. }
  3660. // 13.16.1 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-comma-operator-runtime-semantics-evaluation
  3661. Completion SequenceExpression::execute(Interpreter& interpreter) const
  3662. {
  3663. InterpreterNodeScope node_scope { interpreter, *this };
  3664. // NOTE: Not sure why the last node is an AssignmentExpression in the spec :yakfused:
  3665. // 1. Let lref be the result of evaluating Expression.
  3666. // 2. Perform ? GetValue(lref).
  3667. // 3. Let rref be the result of evaluating AssignmentExpression.
  3668. // 4. Return ? GetValue(rref).
  3669. Value last_value;
  3670. for (auto const& expression : m_expressions)
  3671. last_value = TRY(expression->execute(interpreter)).release_value();
  3672. return { move(last_value) };
  3673. }
  3674. // 14.16.1 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-debugger-statement-runtime-semantics-evaluation
  3675. Completion DebuggerStatement::execute(Interpreter& interpreter) const
  3676. {
  3677. InterpreterNodeScope node_scope { interpreter, *this };
  3678. Completion result;
  3679. // 1. If an implementation-defined debugging facility is available and enabled, then
  3680. if (false) {
  3681. // a. Perform an implementation-defined debugging action.
  3682. // b. Return a new implementation-defined Completion Record.
  3683. VERIFY_NOT_REACHED();
  3684. }
  3685. // 2. Else,
  3686. else {
  3687. // a. Return empty.
  3688. return Optional<Value> {};
  3689. }
  3690. }
  3691. ThrowCompletionOr<void> ScopeNode::for_each_lexically_scoped_declaration(ThrowCompletionOrVoidCallback<Declaration const&>&& callback) const
  3692. {
  3693. for (auto& declaration : m_lexical_declarations)
  3694. TRY(callback(declaration));
  3695. return {};
  3696. }
  3697. ThrowCompletionOr<void> ScopeNode::for_each_lexically_declared_name(ThrowCompletionOrVoidCallback<DeprecatedFlyString const&>&& callback) const
  3698. {
  3699. for (auto const& declaration : m_lexical_declarations) {
  3700. TRY(declaration->for_each_bound_identifier([&](auto const& identifier) {
  3701. return callback(identifier.string());
  3702. }));
  3703. }
  3704. return {};
  3705. }
  3706. ThrowCompletionOr<void> ScopeNode::for_each_lexically_declared_identifier(ThrowCompletionOrVoidCallback<Identifier const&>&& callback) const
  3707. {
  3708. for (auto const& declaration : m_lexical_declarations) {
  3709. TRY(declaration->for_each_bound_identifier([&](auto const& identifier) {
  3710. return callback(identifier);
  3711. }));
  3712. }
  3713. return {};
  3714. }
  3715. ThrowCompletionOr<void> ScopeNode::for_each_var_declared_name(ThrowCompletionOrVoidCallback<DeprecatedFlyString const&>&& callback) const
  3716. {
  3717. for (auto& declaration : m_var_declarations) {
  3718. TRY(declaration->for_each_bound_identifier([&](auto const& identifier) {
  3719. return callback(identifier.string());
  3720. }));
  3721. }
  3722. return {};
  3723. }
  3724. ThrowCompletionOr<void> ScopeNode::for_each_var_declared_identifier(ThrowCompletionOrVoidCallback<Identifier const&>&& callback) const
  3725. {
  3726. for (auto& declaration : m_var_declarations) {
  3727. TRY(declaration->for_each_bound_identifier([&](auto const& id) {
  3728. return callback(id);
  3729. }));
  3730. }
  3731. return {};
  3732. }
  3733. ThrowCompletionOr<void> ScopeNode::for_each_var_function_declaration_in_reverse_order(ThrowCompletionOrVoidCallback<FunctionDeclaration const&>&& callback) const
  3734. {
  3735. for (ssize_t i = m_var_declarations.size() - 1; i >= 0; i--) {
  3736. auto& declaration = m_var_declarations[i];
  3737. if (is<FunctionDeclaration>(declaration))
  3738. TRY(callback(static_cast<FunctionDeclaration const&>(*declaration)));
  3739. }
  3740. return {};
  3741. }
  3742. ThrowCompletionOr<void> ScopeNode::for_each_var_scoped_variable_declaration(ThrowCompletionOrVoidCallback<VariableDeclaration const&>&& callback) const
  3743. {
  3744. for (auto& declaration : m_var_declarations) {
  3745. if (!is<FunctionDeclaration>(declaration)) {
  3746. VERIFY(is<VariableDeclaration>(declaration));
  3747. TRY(callback(static_cast<VariableDeclaration const&>(*declaration)));
  3748. }
  3749. }
  3750. return {};
  3751. }
  3752. ThrowCompletionOr<void> ScopeNode::for_each_function_hoistable_with_annexB_extension(ThrowCompletionOrVoidCallback<FunctionDeclaration&>&& callback) const
  3753. {
  3754. for (auto& function : m_functions_hoistable_with_annexB_extension) {
  3755. // We need const_cast here since it might have to set a property on function declaration.
  3756. TRY(callback(const_cast<FunctionDeclaration&>(*function)));
  3757. }
  3758. return {};
  3759. }
  3760. void ScopeNode::add_lexical_declaration(NonnullRefPtr<Declaration const> declaration)
  3761. {
  3762. m_lexical_declarations.append(move(declaration));
  3763. }
  3764. void ScopeNode::add_var_scoped_declaration(NonnullRefPtr<Declaration const> declaration)
  3765. {
  3766. m_var_declarations.append(move(declaration));
  3767. }
  3768. void ScopeNode::add_hoisted_function(NonnullRefPtr<FunctionDeclaration const> declaration)
  3769. {
  3770. m_functions_hoistable_with_annexB_extension.append(move(declaration));
  3771. }
  3772. // 16.2.1.11 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-module-semantics-runtime-semantics-evaluation
  3773. Completion ImportStatement::execute(Interpreter& interpreter) const
  3774. {
  3775. InterpreterNodeScope node_scope { interpreter, *this };
  3776. // 1. Return empty.
  3777. return Optional<Value> {};
  3778. }
  3779. DeprecatedFlyString ExportStatement::local_name_for_default = "*default*";
  3780. // 16.2.3.7 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-exports-runtime-semantics-evaluation
  3781. Completion ExportStatement::execute(Interpreter& interpreter) const
  3782. {
  3783. InterpreterNodeScope node_scope { interpreter, *this };
  3784. auto& vm = interpreter.vm();
  3785. if (!is_default_export()) {
  3786. if (m_statement) {
  3787. // 1. Return the result of evaluating <Thing>.
  3788. return m_statement->execute(interpreter);
  3789. }
  3790. // 1. Return empty.
  3791. return Optional<Value> {};
  3792. }
  3793. VERIFY(m_statement);
  3794. // ExportDeclaration : export default HoistableDeclaration
  3795. if (is<FunctionDeclaration>(*m_statement)) {
  3796. // 1. Return the result of evaluating HoistableDeclaration.
  3797. return m_statement->execute(interpreter);
  3798. }
  3799. // ExportDeclaration : export default ClassDeclaration
  3800. // ClassDeclaration: class BindingIdentifier[?Yield, ?Await] ClassTail[?Yield, ?Await]
  3801. if (is<ClassDeclaration>(*m_statement)) {
  3802. auto const& class_declaration = static_cast<ClassDeclaration const&>(*m_statement);
  3803. // 1. Let value be ? BindingClassDeclarationEvaluation of ClassDeclaration.
  3804. auto value = TRY(binding_class_declaration_evaluation(interpreter, class_declaration.m_class_expression));
  3805. // 2. Let className be the sole element of BoundNames of ClassDeclaration.
  3806. // 3. If className is "*default*", then
  3807. // Note: We never go into step 3. since a ClassDeclaration always has a name and "*default*" is not a class name.
  3808. (void)value;
  3809. // 4. Return empty.
  3810. return Optional<Value> {};
  3811. }
  3812. // ExportDeclaration : export default ClassDeclaration
  3813. // ClassDeclaration: [+Default] class ClassTail [?Yield, ?Await]
  3814. if (is<ClassExpression>(*m_statement)) {
  3815. auto& class_expression = static_cast<ClassExpression const&>(*m_statement);
  3816. // 1. Let value be ? BindingClassDeclarationEvaluation of ClassDeclaration.
  3817. auto value = TRY(binding_class_declaration_evaluation(interpreter, class_expression));
  3818. // 2. Let className be the sole element of BoundNames of ClassDeclaration.
  3819. // 3. If className is "*default*", then
  3820. if (!class_expression.has_name()) {
  3821. // Note: This can only occur if the class does not have a name since "*default*" is normally not valid.
  3822. // a. Let env be the running execution context's LexicalEnvironment.
  3823. auto* env = interpreter.lexical_environment();
  3824. // b. Perform ? InitializeBoundName("*default*", value, env).
  3825. TRY(initialize_bound_name(vm, ExportStatement::local_name_for_default, value, env));
  3826. }
  3827. // 4. Return empty.
  3828. return Optional<Value> {};
  3829. }
  3830. // ExportDeclaration : export default AssignmentExpression ;
  3831. // 1. If IsAnonymousFunctionDefinition(AssignmentExpression) is true, then
  3832. // a. Let value be ? NamedEvaluation of AssignmentExpression with argument "default".
  3833. // 2. Else,
  3834. // a. Let rhs be the result of evaluating AssignmentExpression.
  3835. // b. Let value be ? GetValue(rhs).
  3836. auto value = TRY(vm.named_evaluation_if_anonymous_function(*m_statement, "default"));
  3837. // 3. Let env be the running execution context's LexicalEnvironment.
  3838. auto* env = interpreter.lexical_environment();
  3839. // 4. Perform ? InitializeBoundName("*default*", value, env).
  3840. TRY(initialize_bound_name(vm, ExportStatement::local_name_for_default, value, env));
  3841. // 5. Return empty.
  3842. return Optional<Value> {};
  3843. }
  3844. static void dump_assert_clauses(ModuleRequest const& request)
  3845. {
  3846. if (!request.assertions.is_empty()) {
  3847. out("[ ");
  3848. for (auto& assertion : request.assertions)
  3849. out("{}: {}, ", assertion.key, assertion.value);
  3850. out(" ]");
  3851. }
  3852. }
  3853. void ExportStatement::dump(int indent) const
  3854. {
  3855. ASTNode::dump(indent);
  3856. print_indent(indent + 1);
  3857. outln("(ExportEntries)");
  3858. auto string_or_null = [](DeprecatedString const& string) -> DeprecatedString {
  3859. if (string.is_empty()) {
  3860. return "null";
  3861. }
  3862. return DeprecatedString::formatted("\"{}\"", string);
  3863. };
  3864. for (auto& entry : m_entries) {
  3865. print_indent(indent + 2);
  3866. out("ExportName: {}, ImportName: {}, LocalName: {}, ModuleRequest: ",
  3867. string_or_null(entry.export_name),
  3868. entry.is_module_request() ? string_or_null(entry.local_or_import_name) : "null",
  3869. entry.is_module_request() ? "null" : string_or_null(entry.local_or_import_name));
  3870. if (entry.is_module_request()) {
  3871. out("{}", entry.m_module_request->module_specifier);
  3872. dump_assert_clauses(*entry.m_module_request);
  3873. outln();
  3874. } else {
  3875. outln("null");
  3876. }
  3877. }
  3878. if (m_statement) {
  3879. print_indent(indent + 1);
  3880. outln("(Statement)");
  3881. m_statement->dump(indent + 2);
  3882. }
  3883. }
  3884. void ImportStatement::dump(int indent) const
  3885. {
  3886. ASTNode::dump(indent);
  3887. print_indent(indent + 1);
  3888. if (m_entries.is_empty()) {
  3889. // direct from "module" import
  3890. outln("Entire module '{}'", m_module_request.module_specifier);
  3891. dump_assert_clauses(m_module_request);
  3892. } else {
  3893. outln("(ExportEntries) from {}", m_module_request.module_specifier);
  3894. dump_assert_clauses(m_module_request);
  3895. for (auto& entry : m_entries) {
  3896. print_indent(indent + 2);
  3897. outln("ImportName: {}, LocalName: {}", entry.import_name, entry.local_name);
  3898. }
  3899. }
  3900. }
  3901. bool ExportStatement::has_export(DeprecatedFlyString const& export_name) const
  3902. {
  3903. return any_of(m_entries.begin(), m_entries.end(), [&](auto& entry) {
  3904. // Make sure that empty exported names does not overlap with anything
  3905. if (entry.kind != ExportEntry::Kind::NamedExport)
  3906. return false;
  3907. return entry.export_name == export_name;
  3908. });
  3909. }
  3910. bool ImportStatement::has_bound_name(DeprecatedFlyString const& name) const
  3911. {
  3912. return any_of(m_entries.begin(), m_entries.end(), [&](auto& entry) {
  3913. return entry.local_name == name;
  3914. });
  3915. }
  3916. // 14.2.3 BlockDeclarationInstantiation ( code, env ), https://tc39.es/ecma262/#sec-blockdeclarationinstantiation
  3917. void ScopeNode::block_declaration_instantiation(VM& vm, Environment* environment) const
  3918. {
  3919. // See also B.3.2.6 Changes to BlockDeclarationInstantiation, https://tc39.es/ecma262/#sec-web-compat-blockdeclarationinstantiation
  3920. auto& realm = *vm.current_realm();
  3921. VERIFY(environment);
  3922. auto private_environment = vm.running_execution_context().private_environment;
  3923. // Note: All the calls here are ! and thus we do not need to TRY this callback.
  3924. // We use MUST to ensure it does not throw and to avoid discarding the returned ThrowCompletionOr<void>.
  3925. MUST(for_each_lexically_scoped_declaration([&](Declaration const& declaration) {
  3926. auto is_constant_declaration = declaration.is_constant_declaration();
  3927. // NOTE: Due to the use of MUST with `create_immutable_binding` and `create_mutable_binding` below,
  3928. // an exception should not result from `for_each_bound_name`.
  3929. MUST(declaration.for_each_bound_identifier([&](auto const& identifier) {
  3930. if (vm.bytecode_interpreter_if_exists() && identifier.is_local()) {
  3931. // NOTE: No need to create bindings for local variables as their values are not stored in an environment.
  3932. return;
  3933. }
  3934. auto const& name = identifier.string();
  3935. if (is_constant_declaration) {
  3936. MUST(environment->create_immutable_binding(vm, name, true));
  3937. } else {
  3938. if (!MUST(environment->has_binding(name)))
  3939. MUST(environment->create_mutable_binding(vm, name, false));
  3940. }
  3941. }));
  3942. if (is<FunctionDeclaration>(declaration)) {
  3943. auto& function_declaration = static_cast<FunctionDeclaration const&>(declaration);
  3944. auto function = ECMAScriptFunctionObject::create(realm, function_declaration.name(), function_declaration.source_text(), function_declaration.body(), function_declaration.parameters(), function_declaration.function_length(), function_declaration.local_variables_names(), environment, private_environment, function_declaration.kind(), function_declaration.is_strict_mode(), function_declaration.might_need_arguments_object(), function_declaration.contains_direct_call_to_eval());
  3945. if (vm.bytecode_interpreter_if_exists() && function_declaration.name_identifier()->is_local()) {
  3946. vm.running_execution_context().local_variables[function_declaration.name_identifier()->local_variable_index()] = function;
  3947. } else {
  3948. VERIFY(is<DeclarativeEnvironment>(*environment));
  3949. static_cast<DeclarativeEnvironment&>(*environment).initialize_or_set_mutable_binding({}, vm, function_declaration.name(), function);
  3950. }
  3951. }
  3952. }));
  3953. }
  3954. // 16.1.7 GlobalDeclarationInstantiation ( script, env ), https://tc39.es/ecma262/#sec-globaldeclarationinstantiation
  3955. ThrowCompletionOr<void> Program::global_declaration_instantiation(VM& vm, GlobalEnvironment& global_environment) const
  3956. {
  3957. auto& realm = *vm.current_realm();
  3958. // 1. Let lexNames be the LexicallyDeclaredNames of script.
  3959. // 2. Let varNames be the VarDeclaredNames of script.
  3960. // 3. For each element name of lexNames, do
  3961. TRY(for_each_lexically_declared_identifier([&](Identifier const& identifier) -> ThrowCompletionOr<void> {
  3962. auto const& name = identifier.string();
  3963. // a. If env.HasVarDeclaration(name) is true, throw a SyntaxError exception.
  3964. if (global_environment.has_var_declaration(name))
  3965. return vm.throw_completion<SyntaxError>(ErrorType::TopLevelVariableAlreadyDeclared, name);
  3966. // b. If env.HasLexicalDeclaration(name) is true, throw a SyntaxError exception.
  3967. if (global_environment.has_lexical_declaration(name))
  3968. return vm.throw_completion<SyntaxError>(ErrorType::TopLevelVariableAlreadyDeclared, name);
  3969. // c. Let hasRestrictedGlobal be ? env.HasRestrictedGlobalProperty(name).
  3970. auto has_restricted_global = TRY(global_environment.has_restricted_global_property(name));
  3971. // d. If hasRestrictedGlobal is true, throw a SyntaxError exception.
  3972. if (has_restricted_global)
  3973. return vm.throw_completion<SyntaxError>(ErrorType::RestrictedGlobalProperty, name);
  3974. return {};
  3975. }));
  3976. // 4. For each element name of varNames, do
  3977. TRY(for_each_var_declared_name([&](auto const& name) -> ThrowCompletionOr<void> {
  3978. // a. If env.HasLexicalDeclaration(name) is true, throw a SyntaxError exception.
  3979. if (global_environment.has_lexical_declaration(name))
  3980. return vm.throw_completion<SyntaxError>(ErrorType::TopLevelVariableAlreadyDeclared, name);
  3981. return {};
  3982. }));
  3983. // 5. Let varDeclarations be the VarScopedDeclarations of script.
  3984. // 6. Let functionsToInitialize be a new empty List.
  3985. Vector<FunctionDeclaration const&> functions_to_initialize;
  3986. // 7. Let declaredFunctionNames be a new empty List.
  3987. HashTable<DeprecatedFlyString> declared_function_names;
  3988. // 8. For each element d of varDeclarations, in reverse List order, do
  3989. TRY(for_each_var_function_declaration_in_reverse_order([&](FunctionDeclaration const& function) -> ThrowCompletionOr<void> {
  3990. // a. If d is neither a VariableDeclaration nor a ForBinding nor a BindingIdentifier, then
  3991. // i. Assert: d is either a FunctionDeclaration, a GeneratorDeclaration, an AsyncFunctionDeclaration, or an AsyncGeneratorDeclaration.
  3992. // Note: This is checked in for_each_var_function_declaration_in_reverse_order.
  3993. // ii. NOTE: If there are multiple function declarations for the same name, the last declaration is used.
  3994. // iii. Let fn be the sole element of the BoundNames of d.
  3995. // iv. If fn is not an element of declaredFunctionNames, then
  3996. if (declared_function_names.set(function.name()) != AK::HashSetResult::InsertedNewEntry)
  3997. return {};
  3998. // 1. Let fnDefinable be ? env.CanDeclareGlobalFunction(fn).
  3999. auto function_definable = TRY(global_environment.can_declare_global_function(function.name()));
  4000. // 2. If fnDefinable is false, throw a TypeError exception.
  4001. if (!function_definable)
  4002. return vm.throw_completion<TypeError>(ErrorType::CannotDeclareGlobalFunction, function.name());
  4003. // 3. Append fn to declaredFunctionNames.
  4004. // Note: Already done in step iv. above.
  4005. // 4. Insert d as the first element of functionsToInitialize.
  4006. // NOTE: Since prepending is much slower, we just append
  4007. // and iterate in reverse order in step 16 below.
  4008. functions_to_initialize.append(function);
  4009. return {};
  4010. }));
  4011. // 9. Let declaredVarNames be a new empty List.
  4012. HashTable<DeprecatedFlyString> declared_var_names;
  4013. // 10. For each element d of varDeclarations, do
  4014. TRY(for_each_var_scoped_variable_declaration([&](Declaration const& declaration) {
  4015. // a. If d is a VariableDeclaration, a ForBinding, or a BindingIdentifier, then
  4016. // Note: This is done in for_each_var_scoped_variable_declaration.
  4017. // i. For each String vn of the BoundNames of d, do
  4018. return declaration.for_each_bound_identifier([&](auto const& identifier) -> ThrowCompletionOr<void> {
  4019. auto const& name = identifier.string();
  4020. // 1. If vn is not an element of declaredFunctionNames, then
  4021. if (declared_function_names.contains(name))
  4022. return {};
  4023. // a. Let vnDefinable be ? env.CanDeclareGlobalVar(vn).
  4024. auto var_definable = TRY(global_environment.can_declare_global_var(name));
  4025. // b. If vnDefinable is false, throw a TypeError exception.
  4026. if (!var_definable)
  4027. return vm.throw_completion<TypeError>(ErrorType::CannotDeclareGlobalVariable, name);
  4028. // c. If vn is not an element of declaredVarNames, then
  4029. // i. Append vn to declaredVarNames.
  4030. declared_var_names.set(name);
  4031. return {};
  4032. });
  4033. }));
  4034. // 11. NOTE: No abnormal terminations occur after this algorithm step if the global object is an ordinary object. However, if the global object is a Proxy exotic object it may exhibit behaviours that cause abnormal terminations in some of the following steps.
  4035. // 12. NOTE: Annex B.3.2.2 adds additional steps at this point.
  4036. // 12. Let strict be IsStrict of script.
  4037. // 13. If strict is false, then
  4038. if (!m_is_strict_mode) {
  4039. // a. Let declaredFunctionOrVarNames be the list-concatenation of declaredFunctionNames and declaredVarNames.
  4040. // b. For each FunctionDeclaration f that is directly contained in the StatementList of a Block, CaseClause, or DefaultClause Contained within script, do
  4041. TRY(for_each_function_hoistable_with_annexB_extension([&](FunctionDeclaration& function_declaration) -> ThrowCompletionOr<void> {
  4042. // i. Let F be StringValue of the BindingIdentifier of f.
  4043. auto function_name = function_declaration.name();
  4044. // ii. If replacing the FunctionDeclaration f with a VariableStatement that has F as a BindingIdentifier would not produce any Early Errors for script, then
  4045. // Note: This step is already performed during parsing and for_each_function_hoistable_with_annexB_extension so this always passes here.
  4046. // 1. If env.HasLexicalDeclaration(F) is false, then
  4047. if (global_environment.has_lexical_declaration(function_name))
  4048. return {};
  4049. // a. Let fnDefinable be ? env.CanDeclareGlobalVar(F).
  4050. auto function_definable = TRY(global_environment.can_declare_global_function(function_name));
  4051. // b. If fnDefinable is true, then
  4052. if (!function_definable)
  4053. return {};
  4054. // i. NOTE: A var binding for F is only instantiated here if it is neither a VarDeclaredName nor the name of another FunctionDeclaration.
  4055. // ii. If declaredFunctionOrVarNames does not contain F, then
  4056. if (!declared_function_names.contains(function_name) && !declared_var_names.contains(function_name)) {
  4057. // i. Perform ? env.CreateGlobalVarBinding(F, false).
  4058. TRY(global_environment.create_global_var_binding(function_name, false));
  4059. // ii. Append F to declaredFunctionOrVarNames.
  4060. declared_function_names.set(function_name);
  4061. }
  4062. // iii. When the FunctionDeclaration f is evaluated, perform the following steps in place of the FunctionDeclaration Evaluation algorithm provided in 15.2.6:
  4063. // i. Let genv be the running execution context's VariableEnvironment.
  4064. // ii. Let benv be the running execution context's LexicalEnvironment.
  4065. // iii. Let fobj be ! benv.GetBindingValue(F, false).
  4066. // iv. Perform ? genv.SetMutableBinding(F, fobj, false).
  4067. // v. Return unused.
  4068. function_declaration.set_should_do_additional_annexB_steps();
  4069. return {};
  4070. }));
  4071. // We should not use declared function names below here anymore since these functions are not in there in the spec.
  4072. declared_function_names.clear();
  4073. }
  4074. // 13. Let lexDeclarations be the LexicallyScopedDeclarations of script.
  4075. // 14. Let privateEnv be null.
  4076. PrivateEnvironment* private_environment = nullptr;
  4077. // 15. For each element d of lexDeclarations, do
  4078. TRY(for_each_lexically_scoped_declaration([&](Declaration const& declaration) {
  4079. // a. NOTE: Lexically declared names are only instantiated here but not initialized.
  4080. // b. For each element dn of the BoundNames of d, do
  4081. return declaration.for_each_bound_identifier([&](auto const& identifier) -> ThrowCompletionOr<void> {
  4082. auto const& name = identifier.string();
  4083. // i. If IsConstantDeclaration of d is true, then
  4084. if (declaration.is_constant_declaration()) {
  4085. // 1. Perform ? env.CreateImmutableBinding(dn, true).
  4086. TRY(global_environment.create_immutable_binding(vm, name, true));
  4087. }
  4088. // ii. Else,
  4089. else {
  4090. // 1. Perform ? env.CreateMutableBinding(dn, false).
  4091. TRY(global_environment.create_mutable_binding(vm, name, false));
  4092. }
  4093. return {};
  4094. });
  4095. }));
  4096. // 16. For each Parse Node f of functionsToInitialize, do
  4097. // NOTE: We iterate in reverse order since we appended the functions
  4098. // instead of prepending. We append because prepending is much slower
  4099. // and we only use the created vector here.
  4100. for (auto& declaration : functions_to_initialize.in_reverse()) {
  4101. // a. Let fn be the sole element of the BoundNames of f.
  4102. // b. Let fo be InstantiateFunctionObject of f with arguments env and privateEnv.
  4103. auto function = ECMAScriptFunctionObject::create(realm, declaration.name(), declaration.source_text(), declaration.body(), declaration.parameters(), declaration.function_length(), declaration.local_variables_names(), &global_environment, private_environment, declaration.kind(), declaration.is_strict_mode(), declaration.might_need_arguments_object(), declaration.contains_direct_call_to_eval());
  4104. // c. Perform ? env.CreateGlobalFunctionBinding(fn, fo, false).
  4105. TRY(global_environment.create_global_function_binding(declaration.name(), function, false));
  4106. }
  4107. // 17. For each String vn of declaredVarNames, do
  4108. for (auto& var_name : declared_var_names) {
  4109. // a. Perform ? env.CreateGlobalVarBinding(vn, false).
  4110. TRY(global_environment.create_global_var_binding(var_name, false));
  4111. }
  4112. // 18. Return unused.
  4113. return {};
  4114. }
  4115. ModuleRequest::ModuleRequest(DeprecatedFlyString module_specifier_, Vector<Assertion> assertions_)
  4116. : module_specifier(move(module_specifier_))
  4117. , assertions(move(assertions_))
  4118. {
  4119. // Perform step 10.e. from EvaluateImportCall, https://tc39.es/proposal-import-assertions/#sec-evaluate-import-call
  4120. // or step 2. from 2.7 Static Semantics: AssertClauseToAssertions, https://tc39.es/proposal-import-assertions/#sec-assert-clause-to-assertions
  4121. // e. / 2. Sort assertions by the code point order of the [[Key]] of each element.
  4122. // NOTE: This sorting is observable only in that hosts are prohibited from distinguishing among assertions by the order they occur in.
  4123. quick_sort(assertions, [](Assertion const& lhs, Assertion const& rhs) {
  4124. return lhs.key < rhs.key;
  4125. });
  4126. }
  4127. DeprecatedString SourceRange::filename() const
  4128. {
  4129. return code->filename().to_deprecated_string();
  4130. }
  4131. NonnullRefPtr<CallExpression> CallExpression::create(SourceRange source_range, NonnullRefPtr<Expression const> callee, ReadonlySpan<Argument> arguments, InvocationStyleEnum invocation_style, InsideParenthesesEnum inside_parens)
  4132. {
  4133. return ASTNodeWithTailArray::create<CallExpression>(arguments.size(), move(source_range), move(callee), arguments, invocation_style, inside_parens);
  4134. }
  4135. NonnullRefPtr<NewExpression> NewExpression::create(SourceRange source_range, NonnullRefPtr<Expression const> callee, ReadonlySpan<Argument> arguments, InvocationStyleEnum invocation_style, InsideParenthesesEnum inside_parens)
  4136. {
  4137. return ASTNodeWithTailArray::create<NewExpression>(arguments.size(), move(source_range), move(callee), arguments, invocation_style, inside_parens);
  4138. }
  4139. }