gdscript_analyzer.cpp 180 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556255725582559256025612562256325642565256625672568256925702571257225732574257525762577257825792580258125822583258425852586258725882589259025912592259325942595259625972598259926002601260226032604260526062607260826092610261126122613261426152616261726182619262026212622262326242625262626272628262926302631263226332634263526362637263826392640264126422643264426452646264726482649265026512652265326542655265626572658265926602661266226632664266526662667266826692670267126722673267426752676267726782679268026812682268326842685268626872688268926902691269226932694269526962697269826992700270127022703270427052706270727082709271027112712271327142715271627172718271927202721272227232724272527262727272827292730273127322733273427352736273727382739274027412742274327442745274627472748274927502751275227532754275527562757275827592760276127622763276427652766276727682769277027712772277327742775277627772778277927802781278227832784278527862787278827892790279127922793279427952796279727982799280028012802280328042805280628072808280928102811281228132814281528162817281828192820282128222823282428252826282728282829283028312832283328342835283628372838283928402841284228432844284528462847284828492850285128522853285428552856285728582859286028612862286328642865286628672868286928702871287228732874287528762877287828792880288128822883288428852886288728882889289028912892289328942895289628972898289929002901290229032904290529062907290829092910291129122913291429152916291729182919292029212922292329242925292629272928292929302931293229332934293529362937293829392940294129422943294429452946294729482949295029512952295329542955295629572958295929602961296229632964296529662967296829692970297129722973297429752976297729782979298029812982298329842985298629872988298929902991299229932994299529962997299829993000300130023003300430053006300730083009301030113012301330143015301630173018301930203021302230233024302530263027302830293030303130323033303430353036303730383039304030413042304330443045304630473048304930503051305230533054305530563057305830593060306130623063306430653066306730683069307030713072307330743075307630773078307930803081308230833084308530863087308830893090309130923093309430953096309730983099310031013102310331043105310631073108310931103111311231133114311531163117311831193120312131223123312431253126312731283129313031313132313331343135313631373138313931403141314231433144314531463147314831493150315131523153315431553156315731583159316031613162316331643165316631673168316931703171317231733174317531763177317831793180318131823183318431853186318731883189319031913192319331943195319631973198319932003201320232033204320532063207320832093210321132123213321432153216321732183219322032213222322332243225322632273228322932303231323232333234323532363237323832393240324132423243324432453246324732483249325032513252325332543255325632573258325932603261326232633264326532663267326832693270327132723273327432753276327732783279328032813282328332843285328632873288328932903291329232933294329532963297329832993300330133023303330433053306330733083309331033113312331333143315331633173318331933203321332233233324332533263327332833293330333133323333333433353336333733383339334033413342334333443345334633473348334933503351335233533354335533563357335833593360336133623363336433653366336733683369337033713372337333743375337633773378337933803381338233833384338533863387338833893390339133923393339433953396339733983399340034013402340334043405340634073408340934103411341234133414341534163417341834193420342134223423342434253426342734283429343034313432343334343435343634373438343934403441344234433444344534463447344834493450345134523453345434553456345734583459346034613462346334643465346634673468346934703471347234733474347534763477347834793480348134823483348434853486348734883489349034913492349334943495349634973498349935003501350235033504350535063507350835093510351135123513351435153516351735183519352035213522352335243525352635273528352935303531353235333534353535363537353835393540354135423543354435453546354735483549355035513552355335543555355635573558355935603561356235633564356535663567356835693570357135723573357435753576357735783579358035813582358335843585358635873588358935903591359235933594359535963597359835993600360136023603360436053606360736083609361036113612361336143615361636173618361936203621362236233624362536263627362836293630363136323633363436353636363736383639364036413642364336443645364636473648364936503651365236533654365536563657365836593660366136623663366436653666366736683669367036713672367336743675367636773678367936803681368236833684368536863687368836893690369136923693369436953696369736983699370037013702370337043705370637073708370937103711371237133714371537163717371837193720372137223723372437253726372737283729373037313732373337343735373637373738373937403741374237433744374537463747374837493750375137523753375437553756375737583759376037613762376337643765376637673768376937703771377237733774377537763777377837793780378137823783378437853786378737883789379037913792379337943795379637973798379938003801380238033804380538063807380838093810381138123813381438153816381738183819382038213822382338243825382638273828382938303831383238333834383538363837383838393840384138423843384438453846384738483849385038513852385338543855385638573858385938603861386238633864386538663867386838693870387138723873387438753876387738783879388038813882388338843885388638873888388938903891389238933894389538963897389838993900390139023903390439053906390739083909391039113912391339143915391639173918391939203921392239233924392539263927392839293930393139323933393439353936393739383939394039413942394339443945394639473948394939503951395239533954395539563957395839593960396139623963396439653966396739683969397039713972397339743975397639773978397939803981398239833984398539863987398839893990399139923993399439953996399739983999400040014002400340044005400640074008400940104011401240134014401540164017401840194020402140224023402440254026402740284029403040314032403340344035403640374038403940404041404240434044404540464047404840494050405140524053405440554056405740584059406040614062406340644065406640674068406940704071407240734074407540764077407840794080408140824083408440854086408740884089409040914092409340944095409640974098409941004101410241034104410541064107410841094110411141124113411441154116411741184119412041214122412341244125412641274128412941304131413241334134413541364137413841394140414141424143414441454146414741484149415041514152415341544155415641574158415941604161416241634164416541664167416841694170417141724173417441754176417741784179418041814182418341844185418641874188418941904191419241934194419541964197419841994200420142024203420442054206420742084209421042114212421342144215421642174218421942204221422242234224422542264227422842294230423142324233423442354236423742384239424042414242424342444245424642474248424942504251425242534254425542564257425842594260426142624263426442654266426742684269427042714272427342744275427642774278427942804281428242834284428542864287428842894290429142924293429442954296429742984299430043014302430343044305430643074308430943104311431243134314431543164317431843194320432143224323432443254326432743284329433043314332433343344335433643374338433943404341434243434344434543464347434843494350435143524353435443554356435743584359436043614362436343644365436643674368436943704371437243734374437543764377437843794380438143824383438443854386438743884389439043914392439343944395439643974398439944004401440244034404440544064407440844094410441144124413441444154416441744184419442044214422442344244425442644274428442944304431443244334434443544364437443844394440444144424443444444454446444744484449445044514452445344544455445644574458445944604461446244634464446544664467446844694470447144724473447444754476447744784479448044814482448344844485448644874488448944904491449244934494449544964497449844994500450145024503450445054506450745084509451045114512451345144515451645174518451945204521452245234524452545264527452845294530453145324533453445354536453745384539454045414542454345444545454645474548454945504551455245534554455545564557455845594560456145624563456445654566456745684569457045714572457345744575457645774578457945804581458245834584458545864587458845894590459145924593459445954596459745984599460046014602460346044605460646074608460946104611461246134614461546164617461846194620462146224623462446254626462746284629463046314632463346344635463646374638463946404641464246434644464546464647464846494650465146524653465446554656465746584659
  1. /*************************************************************************/
  2. /* gdscript_analyzer.cpp */
  3. /*************************************************************************/
  4. /* This file is part of: */
  5. /* GODOT ENGINE */
  6. /* https://godotengine.org */
  7. /*************************************************************************/
  8. /* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur. */
  9. /* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md). */
  10. /* */
  11. /* Permission is hereby granted, free of charge, to any person obtaining */
  12. /* a copy of this software and associated documentation files (the */
  13. /* "Software"), to deal in the Software without restriction, including */
  14. /* without limitation the rights to use, copy, modify, merge, publish, */
  15. /* distribute, sublicense, and/or sell copies of the Software, and to */
  16. /* permit persons to whom the Software is furnished to do so, subject to */
  17. /* the following conditions: */
  18. /* */
  19. /* The above copyright notice and this permission notice shall be */
  20. /* included in all copies or substantial portions of the Software. */
  21. /* */
  22. /* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
  23. /* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
  24. /* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
  25. /* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
  26. /* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
  27. /* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
  28. /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
  29. /*************************************************************************/
  30. #include "gdscript_analyzer.h"
  31. #include "core/config/engine.h"
  32. #include "core/config/project_settings.h"
  33. #include "core/core_string_names.h"
  34. #include "core/io/file_access.h"
  35. #include "core/io/resource_loader.h"
  36. #include "core/object/class_db.h"
  37. #include "core/object/script_language.h"
  38. #include "core/templates/hash_map.h"
  39. #include "gdscript.h"
  40. #include "gdscript_utility_functions.h"
  41. #include "scene/resources/packed_scene.h"
  42. static MethodInfo info_from_utility_func(const StringName &p_function) {
  43. ERR_FAIL_COND_V(!Variant::has_utility_function(p_function), MethodInfo());
  44. MethodInfo info(p_function);
  45. if (Variant::has_utility_function_return_value(p_function)) {
  46. info.return_val.type = Variant::get_utility_function_return_type(p_function);
  47. if (info.return_val.type == Variant::NIL) {
  48. info.return_val.usage |= PROPERTY_USAGE_NIL_IS_VARIANT;
  49. }
  50. }
  51. if (Variant::is_utility_function_vararg(p_function)) {
  52. info.flags |= METHOD_FLAG_VARARG;
  53. } else {
  54. for (int i = 0; i < Variant::get_utility_function_argument_count(p_function); i++) {
  55. PropertyInfo pi;
  56. #ifdef DEBUG_METHODS_ENABLED
  57. pi.name = Variant::get_utility_function_argument_name(p_function, i);
  58. #else
  59. pi.name = "arg" + itos(i + 1);
  60. #endif
  61. pi.type = Variant::get_utility_function_argument_type(p_function, i);
  62. if (pi.type == Variant::NIL) {
  63. pi.usage |= PROPERTY_USAGE_NIL_IS_VARIANT;
  64. }
  65. info.arguments.push_back(pi);
  66. }
  67. }
  68. return info;
  69. }
  70. static GDScriptParser::DataType make_callable_type(const MethodInfo &p_info) {
  71. GDScriptParser::DataType type;
  72. type.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
  73. type.kind = GDScriptParser::DataType::BUILTIN;
  74. type.builtin_type = Variant::CALLABLE;
  75. type.is_constant = true;
  76. type.method_info = p_info;
  77. return type;
  78. }
  79. static GDScriptParser::DataType make_signal_type(const MethodInfo &p_info) {
  80. GDScriptParser::DataType type;
  81. type.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
  82. type.kind = GDScriptParser::DataType::BUILTIN;
  83. type.builtin_type = Variant::SIGNAL;
  84. type.is_constant = true;
  85. type.method_info = p_info;
  86. return type;
  87. }
  88. static GDScriptParser::DataType make_native_meta_type(const StringName &p_class_name) {
  89. GDScriptParser::DataType type;
  90. type.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
  91. type.kind = GDScriptParser::DataType::NATIVE;
  92. type.builtin_type = Variant::OBJECT;
  93. type.is_constant = true;
  94. type.native_type = p_class_name;
  95. type.is_meta_type = true;
  96. return type;
  97. }
  98. static GDScriptParser::DataType make_native_enum_type(const StringName &p_native_class, const StringName &p_enum_name) {
  99. GDScriptParser::DataType type;
  100. type.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
  101. type.kind = GDScriptParser::DataType::ENUM;
  102. type.builtin_type = Variant::INT;
  103. type.is_constant = true;
  104. type.is_meta_type = true;
  105. List<StringName> enum_values;
  106. ClassDB::get_enum_constants(p_native_class, p_enum_name, &enum_values);
  107. for (const StringName &E : enum_values) {
  108. type.enum_values[E] = ClassDB::get_integer_constant(p_native_class, E);
  109. }
  110. return type;
  111. }
  112. static GDScriptParser::DataType make_builtin_meta_type(Variant::Type p_type) {
  113. GDScriptParser::DataType type;
  114. type.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
  115. type.kind = GDScriptParser::DataType::BUILTIN;
  116. type.builtin_type = p_type;
  117. type.is_constant = true;
  118. type.is_meta_type = true;
  119. return type;
  120. }
  121. bool GDScriptAnalyzer::has_member_name_conflict_in_script_class(const StringName &p_member_name, const GDScriptParser::ClassNode *p_class, const GDScriptParser::Node *p_member) {
  122. if (p_class->members_indices.has(p_member_name)) {
  123. int index = p_class->members_indices[p_member_name];
  124. const GDScriptParser::ClassNode::Member *member = &p_class->members[index];
  125. if (member->type == GDScriptParser::ClassNode::Member::VARIABLE ||
  126. member->type == GDScriptParser::ClassNode::Member::CONSTANT ||
  127. member->type == GDScriptParser::ClassNode::Member::ENUM ||
  128. member->type == GDScriptParser::ClassNode::Member::ENUM_VALUE ||
  129. member->type == GDScriptParser::ClassNode::Member::CLASS ||
  130. member->type == GDScriptParser::ClassNode::Member::SIGNAL) {
  131. return true;
  132. }
  133. if (p_member->type != GDScriptParser::Node::FUNCTION && member->type == GDScriptParser::ClassNode::Member::FUNCTION) {
  134. return true;
  135. }
  136. }
  137. return false;
  138. }
  139. bool GDScriptAnalyzer::has_member_name_conflict_in_native_type(const StringName &p_member_name, const StringName &p_native_type_string) {
  140. if (ClassDB::has_signal(p_native_type_string, p_member_name)) {
  141. return true;
  142. }
  143. if (ClassDB::has_property(p_native_type_string, p_member_name)) {
  144. return true;
  145. }
  146. if (ClassDB::has_integer_constant(p_native_type_string, p_member_name)) {
  147. return true;
  148. }
  149. if (p_member_name == CoreStringNames::get_singleton()->_script) {
  150. return true;
  151. }
  152. return false;
  153. }
  154. Error GDScriptAnalyzer::check_native_member_name_conflict(const StringName &p_member_name, const GDScriptParser::Node *p_member_node, const StringName &p_native_type_string) {
  155. if (has_member_name_conflict_in_native_type(p_member_name, p_native_type_string)) {
  156. push_error(vformat(R"(Member "%s" redefined (original in native class '%s'))", p_member_name, p_native_type_string), p_member_node);
  157. return ERR_PARSE_ERROR;
  158. }
  159. if (class_exists(p_member_name)) {
  160. push_error(vformat(R"(The member "%s" shadows a native class.)", p_member_name), p_member_node);
  161. return ERR_PARSE_ERROR;
  162. }
  163. if (GDScriptParser::get_builtin_type(p_member_name) != Variant::VARIANT_MAX) {
  164. push_error(vformat(R"(The member "%s" cannot have the same name as a builtin type.)", p_member_name), p_member_node);
  165. return ERR_PARSE_ERROR;
  166. }
  167. return OK;
  168. }
  169. Error GDScriptAnalyzer::check_class_member_name_conflict(const GDScriptParser::ClassNode *p_class_node, const StringName &p_member_name, const GDScriptParser::Node *p_member_node) {
  170. const GDScriptParser::DataType *current_data_type = &p_class_node->base_type;
  171. while (current_data_type && current_data_type->kind == GDScriptParser::DataType::Kind::CLASS) {
  172. GDScriptParser::ClassNode *current_class_node = current_data_type->class_type;
  173. if (has_member_name_conflict_in_script_class(p_member_name, current_class_node, p_member_node)) {
  174. String parent_class_name = current_class_node->fqcn;
  175. if (current_class_node->identifier != nullptr) {
  176. parent_class_name = current_class_node->identifier->name;
  177. }
  178. push_error(vformat(R"(The member "%s" already exists in parent class %s.)", p_member_name, parent_class_name), p_member_node);
  179. return ERR_PARSE_ERROR;
  180. }
  181. current_data_type = &current_class_node->base_type;
  182. }
  183. // No need for native class recursion because Node exposes all Object's properties.
  184. if (current_data_type && current_data_type->kind == GDScriptParser::DataType::Kind::NATIVE) {
  185. if (current_data_type->native_type != StringName()) {
  186. return check_native_member_name_conflict(
  187. p_member_name,
  188. p_member_node,
  189. current_data_type->native_type);
  190. }
  191. }
  192. return OK;
  193. }
  194. void GDScriptAnalyzer::get_class_node_current_scope_classes(GDScriptParser::ClassNode *p_node, List<GDScriptParser::ClassNode *> *p_list) {
  195. if (p_list->find(p_node) != nullptr) {
  196. return;
  197. }
  198. p_list->push_back(p_node);
  199. // TODO: Try to solve class inheritance if not yet resolving.
  200. // Prioritize node base type over its outer class
  201. if (p_node->base_type.class_type != nullptr) {
  202. get_class_node_current_scope_classes(p_node->base_type.class_type, p_list);
  203. }
  204. if (p_node->outer != nullptr) {
  205. get_class_node_current_scope_classes(p_node->outer, p_list);
  206. }
  207. }
  208. Error GDScriptAnalyzer::resolve_class_inheritance(GDScriptParser::ClassNode *p_class, const GDScriptParser::Node *p_source) {
  209. if (p_source == nullptr && parser->has_class(p_class)) {
  210. p_source = p_class;
  211. }
  212. if (p_class->base_type.is_resolving()) {
  213. push_error(vformat(R"(Could not resolve class "%s": Cyclic reference.)", type_from_metatype(p_class->get_datatype()).to_string()), p_source);
  214. return ERR_PARSE_ERROR;
  215. }
  216. if (!p_class->base_type.has_no_type()) {
  217. // Already resolved.
  218. return OK;
  219. }
  220. if (!parser->has_class(p_class)) {
  221. String script_path = p_class->get_datatype().script_path;
  222. Ref<GDScriptParserRef> parser_ref = get_parser_for(script_path);
  223. if (parser_ref.is_null()) {
  224. push_error(vformat(R"(Could not find script "%s".)", script_path), p_source);
  225. return ERR_PARSE_ERROR;
  226. }
  227. Error err = parser_ref->raise_status(GDScriptParserRef::PARSED);
  228. if (err) {
  229. push_error(vformat(R"(Could not parse script "%s": %s.)", script_path, error_names[err]), p_source);
  230. return ERR_PARSE_ERROR;
  231. }
  232. ERR_FAIL_COND_V_MSG(!parser_ref->get_parser()->has_class(p_class), ERR_PARSE_ERROR, R"(Parser bug: Mismatched external parser.)");
  233. GDScriptAnalyzer *other_analyzer = parser_ref->get_analyzer();
  234. GDScriptParser *other_parser = parser_ref->get_parser();
  235. int error_count = other_parser->errors.size();
  236. other_analyzer->resolve_class_inheritance(p_class);
  237. if (other_parser->errors.size() > error_count) {
  238. push_error(vformat(R"(Could not resolve inheritance for class "%s".)", p_class->fqcn), p_source);
  239. return ERR_PARSE_ERROR;
  240. }
  241. return OK;
  242. }
  243. GDScriptParser::ClassNode *previous_class = parser->current_class;
  244. parser->current_class = p_class;
  245. if (p_class->identifier) {
  246. StringName class_name = p_class->identifier->name;
  247. if (GDScriptParser::get_builtin_type(class_name) < Variant::VARIANT_MAX) {
  248. push_error(vformat(R"(Class "%s" hides a built-in type.)", class_name), p_class->identifier);
  249. } else if (class_exists(class_name)) {
  250. push_error(vformat(R"(Class "%s" hides a native class.)", class_name), p_class->identifier);
  251. } else if (ScriptServer::is_global_class(class_name) && (ScriptServer::get_global_class_path(class_name) != parser->script_path || p_class != parser->head)) {
  252. push_error(vformat(R"(Class "%s" hides a global script class.)", class_name), p_class->identifier);
  253. } else if (ProjectSettings::get_singleton()->has_autoload(class_name) && ProjectSettings::get_singleton()->get_autoload(class_name).is_singleton) {
  254. push_error(vformat(R"(Class "%s" hides an autoload singleton.)", class_name), p_class->identifier);
  255. }
  256. }
  257. GDScriptParser::DataType resolving_datatype;
  258. resolving_datatype.kind = GDScriptParser::DataType::RESOLVING;
  259. p_class->base_type = resolving_datatype;
  260. // Set datatype for class.
  261. GDScriptParser::DataType class_type;
  262. class_type.is_constant = true;
  263. class_type.is_meta_type = true;
  264. class_type.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
  265. class_type.kind = GDScriptParser::DataType::CLASS;
  266. class_type.class_type = p_class;
  267. class_type.script_path = parser->script_path;
  268. class_type.builtin_type = Variant::OBJECT;
  269. p_class->set_datatype(class_type);
  270. GDScriptParser::DataType result;
  271. if (!p_class->extends_used) {
  272. result.type_source = GDScriptParser::DataType::ANNOTATED_INFERRED;
  273. result.kind = GDScriptParser::DataType::NATIVE;
  274. result.native_type = SNAME("RefCounted");
  275. } else {
  276. result.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
  277. GDScriptParser::DataType base;
  278. int extends_index = 0;
  279. if (!p_class->extends_path.is_empty()) {
  280. if (p_class->extends_path.is_relative_path()) {
  281. p_class->extends_path = class_type.script_path.get_base_dir().path_join(p_class->extends_path).simplify_path();
  282. }
  283. Ref<GDScriptParserRef> ext_parser = get_parser_for(p_class->extends_path);
  284. if (ext_parser.is_null()) {
  285. push_error(vformat(R"(Could not resolve super class path "%s".)", p_class->extends_path), p_class);
  286. return ERR_PARSE_ERROR;
  287. }
  288. Error err = ext_parser->raise_status(GDScriptParserRef::INHERITANCE_SOLVED);
  289. if (err != OK) {
  290. push_error(vformat(R"(Could not resolve super class inheritance from "%s".)", p_class->extends_path), p_class);
  291. return err;
  292. }
  293. base = ext_parser->get_parser()->head->get_datatype();
  294. } else {
  295. if (p_class->extends.is_empty()) {
  296. push_error("Could not resolve an empty super class path.", p_class);
  297. return ERR_PARSE_ERROR;
  298. }
  299. const StringName &name = p_class->extends[extends_index++];
  300. base.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
  301. if (ScriptServer::is_global_class(name)) {
  302. String base_path = ScriptServer::get_global_class_path(name);
  303. if (base_path == parser->script_path) {
  304. base = parser->head->get_datatype();
  305. } else {
  306. Ref<GDScriptParserRef> base_parser = get_parser_for(base_path);
  307. if (base_parser.is_null()) {
  308. push_error(vformat(R"(Could not resolve super class "%s".)", name), p_class);
  309. return ERR_PARSE_ERROR;
  310. }
  311. Error err = base_parser->raise_status(GDScriptParserRef::INHERITANCE_SOLVED);
  312. if (err != OK) {
  313. push_error(vformat(R"(Could not resolve super class inheritance from "%s".)", name), p_class);
  314. return err;
  315. }
  316. base = base_parser->get_parser()->head->get_datatype();
  317. }
  318. } else if (ProjectSettings::get_singleton()->has_autoload(name) && ProjectSettings::get_singleton()->get_autoload(name).is_singleton) {
  319. const ProjectSettings::AutoloadInfo &info = ProjectSettings::get_singleton()->get_autoload(name);
  320. if (info.path.get_extension().to_lower() != GDScriptLanguage::get_singleton()->get_extension()) {
  321. push_error(vformat(R"(Singleton %s is not a GDScript.)", info.name), p_class);
  322. return ERR_PARSE_ERROR;
  323. }
  324. Ref<GDScriptParserRef> info_parser = get_parser_for(info.path);
  325. if (info_parser.is_null()) {
  326. push_error(vformat(R"(Could not parse singleton from "%s".)", info.path), p_class);
  327. return ERR_PARSE_ERROR;
  328. }
  329. Error err = info_parser->raise_status(GDScriptParserRef::INHERITANCE_SOLVED);
  330. if (err != OK) {
  331. push_error(vformat(R"(Could not resolve super class inheritance from "%s".)", name), p_class);
  332. return err;
  333. }
  334. base = info_parser->get_parser()->head->get_datatype();
  335. } else if (class_exists(name) && ClassDB::can_instantiate(name)) {
  336. base.kind = GDScriptParser::DataType::NATIVE;
  337. base.native_type = name;
  338. } else {
  339. // Look for other classes in script.
  340. bool found = false;
  341. List<GDScriptParser::ClassNode *> script_classes;
  342. get_class_node_current_scope_classes(p_class, &script_classes);
  343. for (GDScriptParser::ClassNode *look_class : script_classes) {
  344. if (look_class->identifier && look_class->identifier->name == name) {
  345. if (!look_class->get_datatype().is_set()) {
  346. Error err = resolve_class_inheritance(look_class, p_class);
  347. if (err) {
  348. return err;
  349. }
  350. }
  351. base = look_class->get_datatype();
  352. found = true;
  353. break;
  354. }
  355. if (look_class->has_member(name)) {
  356. resolve_class_member(look_class, name, p_class);
  357. base = look_class->get_member(name).get_datatype();
  358. found = true;
  359. break;
  360. }
  361. }
  362. if (!found) {
  363. push_error(vformat(R"(Could not find base class "%s".)", name), p_class);
  364. return ERR_PARSE_ERROR;
  365. }
  366. }
  367. }
  368. for (int index = extends_index; index < p_class->extends.size(); index++) {
  369. if (base.kind != GDScriptParser::DataType::CLASS) {
  370. push_error(R"(Super type "%s" is not a GDScript. Cannot get nested types.)", p_class);
  371. return ERR_PARSE_ERROR;
  372. }
  373. // TODO: Extends could use identifier nodes. That way errors can be pointed out properly and it can be used here.
  374. GDScriptParser::IdentifierNode *id = parser->alloc_node<GDScriptParser::IdentifierNode>();
  375. id->name = p_class->extends[index];
  376. reduce_identifier_from_base(id, &base);
  377. GDScriptParser::DataType id_type = id->get_datatype();
  378. if (!id_type.is_set()) {
  379. push_error(vformat(R"(Could not find type "%s" under base "%s".)", id->name, base.to_string()), p_class);
  380. }
  381. base = id_type;
  382. }
  383. result = base;
  384. }
  385. if (!result.is_set() || result.has_no_type()) {
  386. // TODO: More specific error messages.
  387. push_error(vformat(R"(Could not resolve inheritance for class "%s".)", p_class->identifier == nullptr ? "<main>" : p_class->identifier->name), p_class);
  388. return ERR_PARSE_ERROR;
  389. }
  390. // Check for cyclic inheritance.
  391. const GDScriptParser::ClassNode *base_class = result.class_type;
  392. while (base_class) {
  393. if (base_class->fqcn == p_class->fqcn) {
  394. push_error("Cyclic inheritance.", p_class);
  395. return ERR_PARSE_ERROR;
  396. }
  397. base_class = base_class->base_type.class_type;
  398. }
  399. p_class->base_type = result;
  400. class_type.native_type = result.native_type;
  401. p_class->set_datatype(class_type);
  402. parser->current_class = previous_class;
  403. return OK;
  404. }
  405. Error GDScriptAnalyzer::resolve_class_inheritance(GDScriptParser::ClassNode *p_class, bool p_recursive) {
  406. Error err = resolve_class_inheritance(p_class);
  407. if (err) {
  408. return err;
  409. }
  410. if (p_recursive) {
  411. for (int i = 0; i < p_class->members.size(); i++) {
  412. if (p_class->members[i].type == GDScriptParser::ClassNode::Member::CLASS) {
  413. err = resolve_class_inheritance(p_class->members[i].m_class, true);
  414. if (err) {
  415. return err;
  416. }
  417. }
  418. }
  419. }
  420. return OK;
  421. }
  422. GDScriptParser::DataType GDScriptAnalyzer::resolve_datatype(GDScriptParser::TypeNode *p_type) {
  423. GDScriptParser::DataType bad_type;
  424. bad_type.kind = GDScriptParser::DataType::VARIANT;
  425. bad_type.type_source = GDScriptParser::DataType::INFERRED;
  426. if (p_type == nullptr) {
  427. return bad_type;
  428. }
  429. if (p_type->get_datatype().is_resolving()) {
  430. push_error(R"(Could not resolve datatype: Cyclic reference.)", p_type);
  431. return bad_type;
  432. }
  433. if (!p_type->get_datatype().has_no_type()) {
  434. return p_type->get_datatype();
  435. }
  436. GDScriptParser::DataType resolving_datatype;
  437. resolving_datatype.kind = GDScriptParser::DataType::RESOLVING;
  438. p_type->set_datatype(resolving_datatype);
  439. GDScriptParser::DataType result;
  440. result.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
  441. result.builtin_type = Variant::OBJECT;
  442. if (p_type->type_chain.is_empty()) {
  443. // void.
  444. result.kind = GDScriptParser::DataType::BUILTIN;
  445. result.builtin_type = Variant::NIL;
  446. p_type->set_datatype(result);
  447. return result;
  448. }
  449. StringName first = p_type->type_chain[0]->name;
  450. if (first == SNAME("Variant")) {
  451. if (p_type->type_chain.size() > 1) {
  452. // TODO: Variant does actually have a nested Type though.
  453. push_error(R"(Variant doesn't contain nested types.)", p_type->type_chain[1]);
  454. return bad_type;
  455. }
  456. result.kind = GDScriptParser::DataType::VARIANT;
  457. } else if (first == SNAME("Object")) {
  458. // Object is treated like a native type, not a built-in.
  459. result.kind = GDScriptParser::DataType::NATIVE;
  460. result.native_type = SNAME("Object");
  461. } else if (GDScriptParser::get_builtin_type(first) < Variant::VARIANT_MAX) {
  462. // Built-in types.
  463. if (p_type->type_chain.size() > 1) {
  464. push_error(R"(Built-in types don't contain nested types.)", p_type->type_chain[1]);
  465. return bad_type;
  466. }
  467. result.kind = GDScriptParser::DataType::BUILTIN;
  468. result.builtin_type = GDScriptParser::get_builtin_type(first);
  469. if (result.builtin_type == Variant::ARRAY) {
  470. GDScriptParser::DataType container_type = resolve_datatype(p_type->container_type);
  471. if (container_type.kind != GDScriptParser::DataType::VARIANT) {
  472. container_type.is_meta_type = false;
  473. container_type.is_constant = false;
  474. result.set_container_element_type(container_type);
  475. }
  476. }
  477. } else if (class_exists(first)) {
  478. // Native engine classes.
  479. result.kind = GDScriptParser::DataType::NATIVE;
  480. result.native_type = first;
  481. } else if (ScriptServer::is_global_class(first)) {
  482. if (parser->script_path == ScriptServer::get_global_class_path(first)) {
  483. result = parser->head->get_datatype();
  484. } else {
  485. String path = ScriptServer::get_global_class_path(first);
  486. String ext = path.get_extension();
  487. if (ext == GDScriptLanguage::get_singleton()->get_extension()) {
  488. Ref<GDScriptParserRef> ref = get_parser_for(path);
  489. if (!ref.is_valid() || ref->raise_status(GDScriptParserRef::INHERITANCE_SOLVED) != OK) {
  490. push_error(vformat(R"(Could not parse global class "%s" from "%s".)", first, ScriptServer::get_global_class_path(first)), p_type);
  491. return bad_type;
  492. }
  493. result = ref->get_parser()->head->get_datatype();
  494. } else {
  495. result.kind = GDScriptParser::DataType::SCRIPT;
  496. result.script_type = ResourceLoader::load(path, "Script");
  497. result.native_type = result.script_type->get_instance_base_type();
  498. result.script_path = path;
  499. result.is_constant = true;
  500. result.is_meta_type = false;
  501. }
  502. }
  503. } else if (ProjectSettings::get_singleton()->has_autoload(first) && ProjectSettings::get_singleton()->get_autoload(first).is_singleton) {
  504. const ProjectSettings::AutoloadInfo &autoload = ProjectSettings::get_singleton()->get_autoload(first);
  505. Ref<GDScriptParserRef> ref = get_parser_for(autoload.path);
  506. if (ref->raise_status(GDScriptParserRef::INHERITANCE_SOLVED) != OK) {
  507. push_error(vformat(R"(Could not parse singleton "%s" from "%s".)", first, autoload.path), p_type);
  508. return bad_type;
  509. }
  510. result = ref->get_parser()->head->get_datatype();
  511. } else if (ClassDB::has_enum(parser->current_class->base_type.native_type, first)) {
  512. // Native enum in current class.
  513. result = make_native_enum_type(parser->current_class->base_type.native_type, first);
  514. } else {
  515. // Classes in current scope.
  516. List<GDScriptParser::ClassNode *> script_classes;
  517. get_class_node_current_scope_classes(parser->current_class, &script_classes);
  518. for (GDScriptParser::ClassNode *script_class : script_classes) {
  519. if (script_class->identifier && script_class->identifier->name == first) {
  520. result = script_class->get_datatype();
  521. break;
  522. }
  523. if (script_class->members_indices.has(first)) {
  524. resolve_class_member(script_class, first, p_type);
  525. GDScriptParser::ClassNode::Member member = script_class->get_member(first);
  526. switch (member.type) {
  527. case GDScriptParser::ClassNode::Member::CLASS:
  528. result = member.get_datatype();
  529. break;
  530. case GDScriptParser::ClassNode::Member::ENUM:
  531. result = member.get_datatype();
  532. break;
  533. case GDScriptParser::ClassNode::Member::CONSTANT:
  534. if (member.get_datatype().is_meta_type) {
  535. result = member.get_datatype();
  536. result.is_meta_type = false;
  537. break;
  538. } else if (Ref<Script>(member.constant->initializer->reduced_value).is_valid()) {
  539. Ref<GDScript> gdscript = member.constant->initializer->reduced_value;
  540. if (gdscript.is_valid()) {
  541. Ref<GDScriptParserRef> ref = get_parser_for(gdscript->get_script_path());
  542. if (ref->raise_status(GDScriptParserRef::INHERITANCE_SOLVED) != OK) {
  543. push_error(vformat(R"(Could not parse script from "%s".)", gdscript->get_script_path()), p_type);
  544. return bad_type;
  545. }
  546. result = ref->get_parser()->head->get_datatype();
  547. result.is_meta_type = false;
  548. } else {
  549. Ref<Script> script = member.constant->initializer->reduced_value;
  550. result.kind = GDScriptParser::DataType::SCRIPT;
  551. result.builtin_type = Variant::OBJECT;
  552. result.script_type = script;
  553. result.script_path = script->get_path();
  554. result.native_type = script->get_instance_base_type();
  555. result.is_meta_type = false;
  556. }
  557. break;
  558. }
  559. [[fallthrough]];
  560. default:
  561. push_error(vformat(R"("%s" is a %s but does not contain a type.)", first, member.get_type_name()), p_type);
  562. return bad_type;
  563. }
  564. }
  565. }
  566. }
  567. if (!result.is_set()) {
  568. push_error(vformat(R"("%s" was not found in the current scope.)", first), p_type);
  569. return bad_type;
  570. }
  571. if (p_type->type_chain.size() > 1) {
  572. if (result.kind == GDScriptParser::DataType::CLASS) {
  573. for (int i = 1; i < p_type->type_chain.size(); i++) {
  574. GDScriptParser::DataType base = result;
  575. reduce_identifier_from_base(p_type->type_chain[i], &base);
  576. result = p_type->type_chain[i]->get_datatype();
  577. if (!result.is_set()) {
  578. push_error(vformat(R"(Could not find type "%s" under base "%s".)", p_type->type_chain[i]->name, base.to_string()), p_type->type_chain[1]);
  579. return bad_type;
  580. } else if (!result.is_meta_type) {
  581. push_error(vformat(R"(Member "%s" under base "%s" is not a valid type.)", p_type->type_chain[i]->name, base.to_string()), p_type->type_chain[1]);
  582. return bad_type;
  583. }
  584. }
  585. } else if (result.kind == GDScriptParser::DataType::NATIVE) {
  586. // Only enums allowed for native.
  587. if (!ClassDB::has_enum(result.native_type, p_type->type_chain[1]->name)) {
  588. push_error(vformat(R"(Could not find nested type "%s" under base "%s".)", p_type->type_chain[1]->name, result.to_string()), p_type->type_chain[1]);
  589. return bad_type;
  590. }
  591. if (p_type->type_chain.size() > 2) {
  592. push_error(R"(Enums cannot contain nested types.)", p_type->type_chain[2]);
  593. return bad_type;
  594. }
  595. result = make_native_enum_type(result.native_type, p_type->type_chain[1]->name);
  596. } else {
  597. push_error(vformat(R"(Could not find nested type "%s" under base "%s".)", p_type->type_chain[1]->name, result.to_string()), p_type->type_chain[1]);
  598. return bad_type;
  599. }
  600. }
  601. if (result.builtin_type != Variant::ARRAY && p_type->container_type != nullptr) {
  602. push_error("Only arrays can specify the collection element type.", p_type);
  603. }
  604. p_type->set_datatype(result);
  605. return result;
  606. }
  607. void GDScriptAnalyzer::resolve_class_member(GDScriptParser::ClassNode *p_class, StringName p_name, const GDScriptParser::Node *p_source) {
  608. ERR_FAIL_COND(!p_class->has_member(p_name));
  609. resolve_class_member(p_class, p_class->members_indices[p_name], p_source);
  610. }
  611. void GDScriptAnalyzer::resolve_class_member(GDScriptParser::ClassNode *p_class, int p_index, const GDScriptParser::Node *p_source) {
  612. ERR_FAIL_INDEX(p_index, p_class->members.size());
  613. GDScriptParser::ClassNode::Member &member = p_class->members.write[p_index];
  614. if (p_source == nullptr && parser->has_class(p_class)) {
  615. p_source = member.get_source_node();
  616. }
  617. if (member.get_datatype().is_resolving()) {
  618. push_error(vformat(R"(Could not resolve member "%s": Cyclic reference.)", member.get_name()), p_source);
  619. return;
  620. }
  621. if (member.get_datatype().is_set()) {
  622. return;
  623. }
  624. if (!parser->has_class(p_class)) {
  625. String script_path = p_class->get_datatype().script_path;
  626. Ref<GDScriptParserRef> parser_ref = get_parser_for(script_path);
  627. if (parser_ref.is_null()) {
  628. push_error(vformat(R"(Could not find script "%s" (While resolving "%s").)", script_path, member.get_name()), p_source);
  629. return;
  630. }
  631. Error err = parser_ref->raise_status(GDScriptParserRef::PARSED);
  632. if (err) {
  633. push_error(vformat(R"(Could not resolve script "%s": %s (While resolving "%s").)", script_path, error_names[err], member.get_name()), p_source);
  634. return;
  635. }
  636. ERR_FAIL_COND_MSG(!parser_ref->get_parser()->has_class(p_class), R"(Parser bug: Mismatched external parser.)");
  637. GDScriptAnalyzer *other_analyzer = parser_ref->get_analyzer();
  638. GDScriptParser *other_parser = parser_ref->get_parser();
  639. int error_count = other_parser->errors.size();
  640. other_analyzer->resolve_class_member(p_class, p_index);
  641. if (other_parser->errors.size() > error_count) {
  642. push_error(vformat(R"(Could not resolve member "%s".)", member.get_name()), p_source);
  643. }
  644. return;
  645. }
  646. // If it's already resolving, that's ok.
  647. if (!p_class->base_type.is_resolving()) {
  648. Error err = resolve_class_inheritance(p_class);
  649. if (err) {
  650. return;
  651. }
  652. }
  653. GDScriptParser::ClassNode *previous_class = parser->current_class;
  654. parser->current_class = p_class;
  655. GDScriptParser::DataType resolving_datatype;
  656. resolving_datatype.kind = GDScriptParser::DataType::RESOLVING;
  657. {
  658. switch (member.type) {
  659. case GDScriptParser::ClassNode::Member::VARIABLE: {
  660. check_class_member_name_conflict(p_class, member.variable->identifier->name, member.variable);
  661. member.variable->set_datatype(resolving_datatype);
  662. GDScriptParser::DataType datatype;
  663. datatype.kind = GDScriptParser::DataType::VARIANT;
  664. datatype.type_source = GDScriptParser::DataType::UNDETECTED;
  665. GDScriptParser::DataType specified_type;
  666. if (member.variable->datatype_specifier != nullptr) {
  667. specified_type = resolve_datatype(member.variable->datatype_specifier);
  668. specified_type.is_meta_type = false;
  669. }
  670. if (member.variable->initializer != nullptr) {
  671. reduce_expression(member.variable->initializer);
  672. if ((member.variable->infer_datatype || (member.variable->datatype_specifier != nullptr && specified_type.has_container_element_type())) && member.variable->initializer->type == GDScriptParser::Node::ARRAY) {
  673. // Typed array.
  674. GDScriptParser::ArrayNode *array = static_cast<GDScriptParser::ArrayNode *>(member.variable->initializer);
  675. // Can only infer typed array if it has elements.
  676. if ((member.variable->infer_datatype && array->elements.size() > 0) || member.variable->datatype_specifier != nullptr) {
  677. update_array_literal_element_type(specified_type, array);
  678. }
  679. }
  680. datatype = member.variable->initializer->get_datatype();
  681. if (datatype.type_source != GDScriptParser::DataType::UNDETECTED) {
  682. datatype.type_source = GDScriptParser::DataType::INFERRED;
  683. }
  684. if (!datatype.is_set()) {
  685. push_error(vformat(R"(Could not resolve initializer for member "%s".)", member.variable->identifier->name), member.variable->initializer);
  686. datatype.kind = GDScriptParser::DataType::VARIANT;
  687. }
  688. }
  689. if (member.variable->datatype_specifier != nullptr) {
  690. datatype = specified_type;
  691. if (member.variable->initializer != nullptr) {
  692. if (!is_type_compatible(datatype, member.variable->initializer->get_datatype(), true, member.variable->initializer)) {
  693. // Try reverse test since it can be a masked subtype.
  694. if (!is_type_compatible(member.variable->initializer->get_datatype(), datatype, true, member.variable->initializer)) {
  695. push_error(vformat(R"(Value of type "%s" cannot be assigned to a variable of type "%s".)", member.variable->initializer->get_datatype().to_string(), datatype.to_string()), member.variable->initializer);
  696. } else {
  697. // TODO: Add warning.
  698. mark_node_unsafe(member.variable->initializer);
  699. member.variable->use_conversion_assign = true;
  700. }
  701. } else if (datatype.builtin_type == Variant::INT && member.variable->initializer->get_datatype().builtin_type == Variant::FLOAT) {
  702. #ifdef DEBUG_ENABLED
  703. parser->push_warning(member.variable->initializer, GDScriptWarning::NARROWING_CONVERSION);
  704. #endif
  705. }
  706. if (member.variable->initializer->get_datatype().is_variant()) {
  707. // TODO: Warn unsafe assign.
  708. mark_node_unsafe(member.variable->initializer);
  709. member.variable->use_conversion_assign = true;
  710. }
  711. }
  712. } else if (member.variable->infer_datatype) {
  713. if (member.variable->initializer == nullptr) {
  714. push_error(vformat(R"(Cannot infer the type of "%s" variable because there's no default value.)", member.variable->identifier->name), member.variable->identifier);
  715. } else if (!datatype.is_set() || datatype.has_no_type()) {
  716. push_error(vformat(R"(Cannot infer the type of "%s" variable because the initial value doesn't have a set type.)", member.variable->identifier->name), member.variable->initializer);
  717. } else if (datatype.is_variant()) {
  718. push_error(vformat(R"(Cannot infer the type of "%s" variable because the initial value is Variant. Use explicit "Variant" type if this is intended.)", member.variable->identifier->name), member.variable->initializer);
  719. } else if (datatype.builtin_type == Variant::NIL) {
  720. push_error(vformat(R"(Cannot infer the type of "%s" variable because the initial value is "null".)", member.variable->identifier->name), member.variable->initializer);
  721. }
  722. datatype.type_source = GDScriptParser::DataType::ANNOTATED_INFERRED;
  723. }
  724. datatype.is_constant = false;
  725. member.variable->set_datatype(datatype);
  726. // Apply annotations.
  727. for (GDScriptParser::AnnotationNode *&E : member.variable->annotations) {
  728. E->apply(parser, member.variable);
  729. }
  730. } break;
  731. case GDScriptParser::ClassNode::Member::CONSTANT: {
  732. check_class_member_name_conflict(p_class, member.constant->identifier->name, member.constant);
  733. member.constant->set_datatype(resolving_datatype);
  734. GDScriptParser::DataType specified_type;
  735. if (member.constant->datatype_specifier != nullptr) {
  736. specified_type = resolve_datatype(member.constant->datatype_specifier);
  737. specified_type.is_meta_type = false;
  738. }
  739. GDScriptParser::DataType datatype;
  740. if (member.constant->initializer) {
  741. reduce_expression(member.constant->initializer);
  742. datatype = member.constant->initializer->get_datatype();
  743. if (member.constant->initializer->type == GDScriptParser::Node::ARRAY) {
  744. GDScriptParser::ArrayNode *array = static_cast<GDScriptParser::ArrayNode *>(member.constant->initializer);
  745. const_fold_array(array);
  746. // Can only infer typed array if it has elements.
  747. if (array->elements.size() > 0 || (member.constant->datatype_specifier != nullptr && specified_type.has_container_element_type())) {
  748. update_array_literal_element_type(specified_type, array);
  749. }
  750. } else if (member.constant->initializer->type == GDScriptParser::Node::DICTIONARY) {
  751. const_fold_dictionary(static_cast<GDScriptParser::DictionaryNode *>(member.constant->initializer));
  752. }
  753. if (!datatype.is_set()) {
  754. push_error(vformat(R"(Could not resolve initializer for member "%s".)", member.constant->identifier->name), member.constant->initializer);
  755. datatype.kind = GDScriptParser::DataType::VARIANT;
  756. }
  757. if (!member.constant->initializer->is_constant) {
  758. push_error(R"(Initializer for a constant must be a constant expression.)", member.constant->initializer);
  759. }
  760. if (member.constant->datatype_specifier != nullptr) {
  761. datatype = specified_type;
  762. if (!is_type_compatible(datatype, member.constant->initializer->get_datatype(), true)) {
  763. push_error(vformat(R"(Value of type "%s" cannot be initialized to constant of type "%s".)", member.constant->initializer->get_datatype().to_string(), datatype.to_string()), member.constant->initializer);
  764. } else if (datatype.builtin_type == Variant::INT && member.constant->initializer->get_datatype().builtin_type == Variant::FLOAT) {
  765. #ifdef DEBUG_ENABLED
  766. parser->push_warning(member.constant->initializer, GDScriptWarning::NARROWING_CONVERSION);
  767. #endif
  768. }
  769. }
  770. }
  771. datatype.is_constant = true;
  772. member.constant->set_datatype(datatype);
  773. // Apply annotations.
  774. for (GDScriptParser::AnnotationNode *&E : member.constant->annotations) {
  775. E->apply(parser, member.constant);
  776. }
  777. } break;
  778. case GDScriptParser::ClassNode::Member::SIGNAL: {
  779. check_class_member_name_conflict(p_class, member.signal->identifier->name, member.signal);
  780. member.signal->set_datatype(resolving_datatype);
  781. for (int j = 0; j < member.signal->parameters.size(); j++) {
  782. GDScriptParser::DataType signal_type = resolve_datatype(member.signal->parameters[j]->datatype_specifier);
  783. signal_type.is_meta_type = false;
  784. member.signal->parameters[j]->set_datatype(signal_type);
  785. }
  786. // TODO: Make MethodInfo from signal.
  787. GDScriptParser::DataType signal_type;
  788. signal_type.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
  789. signal_type.kind = GDScriptParser::DataType::BUILTIN;
  790. signal_type.builtin_type = Variant::SIGNAL;
  791. member.signal->set_datatype(signal_type);
  792. // Apply annotations.
  793. for (GDScriptParser::AnnotationNode *&E : member.signal->annotations) {
  794. E->apply(parser, member.signal);
  795. }
  796. } break;
  797. case GDScriptParser::ClassNode::Member::ENUM: {
  798. check_class_member_name_conflict(p_class, member.m_enum->identifier->name, member.m_enum);
  799. member.m_enum->set_datatype(resolving_datatype);
  800. GDScriptParser::DataType enum_type;
  801. enum_type.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
  802. enum_type.kind = GDScriptParser::DataType::ENUM;
  803. enum_type.builtin_type = Variant::DICTIONARY;
  804. enum_type.enum_type = member.m_enum->identifier->name;
  805. enum_type.native_type = p_class->fqcn + "." + member.m_enum->identifier->name;
  806. enum_type.is_meta_type = true;
  807. enum_type.is_constant = true;
  808. const GDScriptParser::EnumNode *prev_enum = current_enum;
  809. current_enum = member.m_enum;
  810. for (int j = 0; j < member.m_enum->values.size(); j++) {
  811. GDScriptParser::EnumNode::Value &element = member.m_enum->values.write[j];
  812. if (element.custom_value) {
  813. reduce_expression(element.custom_value);
  814. if (!element.custom_value->is_constant) {
  815. push_error(R"(Enum values must be constant.)", element.custom_value);
  816. } else if (element.custom_value->reduced_value.get_type() != Variant::INT) {
  817. push_error(R"(Enum values must be integers.)", element.custom_value);
  818. } else {
  819. element.value = element.custom_value->reduced_value;
  820. element.resolved = true;
  821. }
  822. } else {
  823. if (element.index > 0) {
  824. element.value = element.parent_enum->values[element.index - 1].value + 1;
  825. } else {
  826. element.value = 0;
  827. }
  828. element.resolved = true;
  829. }
  830. enum_type.enum_values[element.identifier->name] = element.value;
  831. }
  832. current_enum = prev_enum;
  833. member.m_enum->set_datatype(enum_type);
  834. // Apply annotations.
  835. for (GDScriptParser::AnnotationNode *&E : member.m_enum->annotations) {
  836. E->apply(parser, member.m_enum);
  837. }
  838. } break;
  839. case GDScriptParser::ClassNode::Member::FUNCTION:
  840. resolve_function_signature(member.function, p_source);
  841. break;
  842. case GDScriptParser::ClassNode::Member::ENUM_VALUE: {
  843. if (member.enum_value.custom_value) {
  844. check_class_member_name_conflict(p_class, member.enum_value.identifier->name, member.enum_value.custom_value);
  845. member.enum_value.identifier->set_datatype(resolving_datatype);
  846. const GDScriptParser::EnumNode *prev_enum = current_enum;
  847. current_enum = member.enum_value.parent_enum;
  848. reduce_expression(member.enum_value.custom_value);
  849. current_enum = prev_enum;
  850. if (!member.enum_value.custom_value->is_constant) {
  851. push_error(R"(Enum values must be constant.)", member.enum_value.custom_value);
  852. } else if (member.enum_value.custom_value->reduced_value.get_type() != Variant::INT) {
  853. push_error(R"(Enum values must be integers.)", member.enum_value.custom_value);
  854. } else {
  855. member.enum_value.value = member.enum_value.custom_value->reduced_value;
  856. member.enum_value.resolved = true;
  857. }
  858. } else {
  859. check_class_member_name_conflict(p_class, member.enum_value.identifier->name, member.enum_value.parent_enum);
  860. if (member.enum_value.index > 0) {
  861. member.enum_value.value = member.enum_value.parent_enum->values[member.enum_value.index - 1].value + 1;
  862. } else {
  863. member.enum_value.value = 0;
  864. }
  865. member.enum_value.resolved = true;
  866. }
  867. // Also update the original references.
  868. member.enum_value.parent_enum->values.set(member.enum_value.index, member.enum_value);
  869. GDScriptParser::DataType datatype;
  870. datatype.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
  871. datatype.kind = GDScriptParser::DataType::BUILTIN;
  872. datatype.builtin_type = Variant::INT;
  873. member.enum_value.identifier->set_datatype(datatype);
  874. } break;
  875. case GDScriptParser::ClassNode::Member::CLASS:
  876. check_class_member_name_conflict(p_class, member.m_class->identifier->name, member.m_class);
  877. // If it's already resolving, that's ok.
  878. if (!member.m_class->base_type.is_resolving()) {
  879. resolve_class_inheritance(member.m_class, p_source);
  880. }
  881. break;
  882. case GDScriptParser::ClassNode::Member::GROUP:
  883. // No-op, but needed to silence warnings.
  884. break;
  885. case GDScriptParser::ClassNode::Member::UNDEFINED:
  886. ERR_PRINT("Trying to resolve undefined member.");
  887. break;
  888. }
  889. }
  890. parser->current_class = previous_class;
  891. }
  892. void GDScriptAnalyzer::resolve_class_interface(GDScriptParser::ClassNode *p_class, const GDScriptParser::Node *p_source) {
  893. if (p_source == nullptr && parser->has_class(p_class)) {
  894. p_source = p_class;
  895. }
  896. if (!p_class->resolved_interface) {
  897. if (!parser->has_class(p_class)) {
  898. String script_path = p_class->get_datatype().script_path;
  899. Ref<GDScriptParserRef> parser_ref = get_parser_for(script_path);
  900. if (parser_ref.is_null()) {
  901. push_error(vformat(R"(Could not find script "%s".)", script_path), p_source);
  902. return;
  903. }
  904. Error err = parser_ref->raise_status(GDScriptParserRef::PARSED);
  905. if (err) {
  906. push_error(vformat(R"(Could not resolve script "%s": %s.)", script_path, error_names[err]), p_source);
  907. return;
  908. }
  909. ERR_FAIL_COND_MSG(!parser_ref->get_parser()->has_class(p_class), R"(Parser bug: Mismatched external parser.)");
  910. GDScriptAnalyzer *other_analyzer = parser_ref->get_analyzer();
  911. GDScriptParser *other_parser = parser_ref->get_parser();
  912. int error_count = other_parser->errors.size();
  913. other_analyzer->resolve_class_interface(p_class);
  914. if (other_parser->errors.size() > error_count) {
  915. push_error(vformat(R"(Could not resolve class "%s".)", p_class->fqcn), p_source);
  916. }
  917. return;
  918. }
  919. p_class->resolved_interface = true;
  920. if (resolve_class_inheritance(p_class) != OK) {
  921. return;
  922. }
  923. GDScriptParser::DataType base_type = p_class->base_type;
  924. if (base_type.kind == GDScriptParser::DataType::CLASS) {
  925. GDScriptParser::ClassNode *base_class = base_type.class_type;
  926. resolve_class_interface(base_class, p_class);
  927. }
  928. for (int i = 0; i < p_class->members.size(); i++) {
  929. resolve_class_member(p_class, i);
  930. }
  931. }
  932. }
  933. void GDScriptAnalyzer::resolve_class_interface(GDScriptParser::ClassNode *p_class, bool p_recursive) {
  934. resolve_class_interface(p_class);
  935. if (p_recursive) {
  936. for (int i = 0; i < p_class->members.size(); i++) {
  937. GDScriptParser::ClassNode::Member member = p_class->members[i];
  938. if (member.type == GDScriptParser::ClassNode::Member::CLASS) {
  939. resolve_class_interface(member.m_class, true);
  940. }
  941. }
  942. }
  943. }
  944. void GDScriptAnalyzer::resolve_class_body(GDScriptParser::ClassNode *p_class, const GDScriptParser::Node *p_source) {
  945. if (p_source == nullptr && parser->has_class(p_class)) {
  946. p_source = p_class;
  947. }
  948. if (p_class->resolved_body) {
  949. return;
  950. }
  951. if (!parser->has_class(p_class)) {
  952. String script_path = p_class->get_datatype().script_path;
  953. Ref<GDScriptParserRef> parser_ref = get_parser_for(script_path);
  954. if (parser_ref.is_null()) {
  955. push_error(vformat(R"(Could not find script "%s".)", script_path), p_source);
  956. return;
  957. }
  958. Error err = parser_ref->raise_status(GDScriptParserRef::PARSED);
  959. if (err) {
  960. push_error(vformat(R"(Could not resolve script "%s": %s.)", script_path, error_names[err]), p_source);
  961. return;
  962. }
  963. ERR_FAIL_COND_MSG(!parser_ref->get_parser()->has_class(p_class), R"(Parser bug: Mismatched external parser.)");
  964. GDScriptAnalyzer *other_analyzer = parser_ref->get_analyzer();
  965. GDScriptParser *other_parser = parser_ref->get_parser();
  966. int error_count = other_parser->errors.size();
  967. other_analyzer->resolve_class_body(p_class);
  968. if (other_parser->errors.size() > error_count) {
  969. push_error(vformat(R"(Could not resolve class "%s".)", p_class->fqcn), p_source);
  970. }
  971. return;
  972. }
  973. p_class->resolved_body = true;
  974. GDScriptParser::ClassNode *previous_class = parser->current_class;
  975. parser->current_class = p_class;
  976. resolve_class_interface(p_class, p_source);
  977. GDScriptParser::DataType base_type = p_class->base_type;
  978. if (base_type.kind == GDScriptParser::DataType::CLASS) {
  979. GDScriptParser::ClassNode *base_class = base_type.class_type;
  980. resolve_class_body(base_class, p_class);
  981. }
  982. // Do functions and properties now.
  983. for (int i = 0; i < p_class->members.size(); i++) {
  984. GDScriptParser::ClassNode::Member member = p_class->members[i];
  985. if (member.type == GDScriptParser::ClassNode::Member::FUNCTION) {
  986. // Apply annotations.
  987. for (GDScriptParser::AnnotationNode *&E : member.function->annotations) {
  988. E->apply(parser, member.function);
  989. }
  990. #ifdef DEBUG_ENABLED
  991. HashSet<uint32_t> previously_ignored = parser->ignored_warning_codes;
  992. for (uint32_t ignored_warning : member.function->ignored_warnings) {
  993. parser->ignored_warning_codes.insert(ignored_warning);
  994. }
  995. #endif // DEBUG_ENABLED
  996. resolve_function_body(member.function);
  997. #ifdef DEBUG_ENABLED
  998. parser->ignored_warning_codes = previously_ignored;
  999. #endif // DEBUG_ENABLED
  1000. } else if (member.type == GDScriptParser::ClassNode::Member::VARIABLE && member.variable->property != GDScriptParser::VariableNode::PROP_NONE) {
  1001. if (member.variable->property == GDScriptParser::VariableNode::PROP_INLINE) {
  1002. if (member.variable->getter != nullptr) {
  1003. member.variable->getter->set_datatype(member.variable->datatype);
  1004. resolve_function_body(member.variable->getter);
  1005. }
  1006. if (member.variable->setter != nullptr) {
  1007. resolve_function_signature(member.variable->setter);
  1008. if (member.variable->setter->parameters.size() > 0) {
  1009. member.variable->setter->parameters[0]->datatype_specifier = member.variable->datatype_specifier;
  1010. member.variable->setter->parameters[0]->set_datatype(member.get_datatype());
  1011. }
  1012. resolve_function_body(member.variable->setter);
  1013. }
  1014. }
  1015. }
  1016. }
  1017. // Check unused variables and datatypes of property getters and setters.
  1018. for (int i = 0; i < p_class->members.size(); i++) {
  1019. GDScriptParser::ClassNode::Member member = p_class->members[i];
  1020. if (member.type == GDScriptParser::ClassNode::Member::VARIABLE) {
  1021. #ifdef DEBUG_ENABLED
  1022. HashSet<uint32_t> previously_ignored = parser->ignored_warning_codes;
  1023. for (uint32_t ignored_warning : member.function->ignored_warnings) {
  1024. parser->ignored_warning_codes.insert(ignored_warning);
  1025. }
  1026. if (member.variable->usages == 0 && String(member.variable->identifier->name).begins_with("_")) {
  1027. parser->push_warning(member.variable->identifier, GDScriptWarning::UNUSED_PRIVATE_CLASS_VARIABLE, member.variable->identifier->name);
  1028. }
  1029. #endif
  1030. if (member.variable->property == GDScriptParser::VariableNode::PROP_SETGET) {
  1031. GDScriptParser::FunctionNode *getter_function = nullptr;
  1032. GDScriptParser::FunctionNode *setter_function = nullptr;
  1033. bool has_valid_getter = false;
  1034. bool has_valid_setter = false;
  1035. if (member.variable->getter_pointer != nullptr) {
  1036. if (p_class->has_function(member.variable->getter_pointer->name)) {
  1037. getter_function = p_class->get_member(member.variable->getter_pointer->name).function;
  1038. }
  1039. if (getter_function == nullptr) {
  1040. push_error(vformat(R"(Getter "%s" not found.)", member.variable->getter_pointer->name), member.variable);
  1041. } else {
  1042. GDScriptParser::DataType return_datatype = getter_function->datatype;
  1043. if (getter_function->return_type != nullptr) {
  1044. return_datatype = getter_function->return_type->datatype;
  1045. return_datatype.is_meta_type = false;
  1046. }
  1047. if (getter_function->parameters.size() != 0 || return_datatype.has_no_type()) {
  1048. push_error(vformat(R"(Function "%s" cannot be used as getter because of its signature.)", getter_function->identifier->name), member.variable);
  1049. } else if (!is_type_compatible(member.variable->datatype, return_datatype, true)) {
  1050. push_error(vformat(R"(Function with return type "%s" cannot be used as getter for a property of type "%s".)", return_datatype.to_string(), member.variable->datatype.to_string()), member.variable);
  1051. } else {
  1052. has_valid_getter = true;
  1053. #ifdef DEBUG_ENABLED
  1054. if (member.variable->datatype.builtin_type == Variant::INT && return_datatype.builtin_type == Variant::FLOAT) {
  1055. parser->push_warning(member.variable, GDScriptWarning::NARROWING_CONVERSION);
  1056. }
  1057. #endif
  1058. }
  1059. }
  1060. }
  1061. if (member.variable->setter_pointer != nullptr) {
  1062. if (p_class->has_function(member.variable->setter_pointer->name)) {
  1063. setter_function = p_class->get_member(member.variable->setter_pointer->name).function;
  1064. }
  1065. if (setter_function == nullptr) {
  1066. push_error(vformat(R"(Setter "%s" not found.)", member.variable->setter_pointer->name), member.variable);
  1067. } else if (setter_function->parameters.size() != 1) {
  1068. push_error(vformat(R"(Function "%s" cannot be used as setter because of its signature.)", setter_function->identifier->name), member.variable);
  1069. } else if (!is_type_compatible(member.variable->datatype, setter_function->parameters[0]->datatype, true)) {
  1070. push_error(vformat(R"(Function with argument type "%s" cannot be used as setter for a property of type "%s".)", setter_function->parameters[0]->datatype.to_string(), member.variable->datatype.to_string()), member.variable);
  1071. } else {
  1072. has_valid_setter = true;
  1073. #ifdef DEBUG_ENABLED
  1074. if (member.variable->datatype.builtin_type == Variant::FLOAT && setter_function->parameters[0]->datatype.builtin_type == Variant::INT) {
  1075. parser->push_warning(member.variable, GDScriptWarning::NARROWING_CONVERSION);
  1076. }
  1077. #endif
  1078. }
  1079. }
  1080. if (member.variable->datatype.is_variant() && has_valid_getter && has_valid_setter) {
  1081. if (!is_type_compatible(getter_function->datatype, setter_function->parameters[0]->datatype, true)) {
  1082. push_error(vformat(R"(Getter with type "%s" cannot be used along with setter of type "%s".)", getter_function->datatype.to_string(), setter_function->parameters[0]->datatype.to_string()), member.variable);
  1083. }
  1084. }
  1085. #ifdef DEBUG_ENABLED
  1086. parser->ignored_warning_codes = previously_ignored;
  1087. #endif // DEBUG_ENABLED
  1088. }
  1089. }
  1090. }
  1091. parser->current_class = previous_class;
  1092. }
  1093. void GDScriptAnalyzer::resolve_class_body(GDScriptParser::ClassNode *p_class, bool p_recursive) {
  1094. resolve_class_body(p_class);
  1095. if (p_recursive) {
  1096. for (int i = 0; i < p_class->members.size(); i++) {
  1097. GDScriptParser::ClassNode::Member member = p_class->members[i];
  1098. if (member.type == GDScriptParser::ClassNode::Member::CLASS) {
  1099. resolve_class_body(member.m_class, true);
  1100. }
  1101. }
  1102. }
  1103. }
  1104. void GDScriptAnalyzer::resolve_node(GDScriptParser::Node *p_node, bool p_is_root) {
  1105. ERR_FAIL_COND_MSG(p_node == nullptr, "Trying to resolve type of a null node.");
  1106. switch (p_node->type) {
  1107. case GDScriptParser::Node::NONE:
  1108. break; // Unreachable.
  1109. case GDScriptParser::Node::CLASS:
  1110. if (OK == resolve_class_inheritance(static_cast<GDScriptParser::ClassNode *>(p_node), true)) {
  1111. resolve_class_interface(static_cast<GDScriptParser::ClassNode *>(p_node), true);
  1112. resolve_class_body(static_cast<GDScriptParser::ClassNode *>(p_node), true);
  1113. }
  1114. break;
  1115. case GDScriptParser::Node::CONSTANT:
  1116. resolve_constant(static_cast<GDScriptParser::ConstantNode *>(p_node));
  1117. break;
  1118. case GDScriptParser::Node::FOR:
  1119. resolve_for(static_cast<GDScriptParser::ForNode *>(p_node));
  1120. break;
  1121. case GDScriptParser::Node::FUNCTION:
  1122. resolve_function_signature(static_cast<GDScriptParser::FunctionNode *>(p_node));
  1123. resolve_function_body(static_cast<GDScriptParser::FunctionNode *>(p_node));
  1124. break;
  1125. case GDScriptParser::Node::IF:
  1126. resolve_if(static_cast<GDScriptParser::IfNode *>(p_node));
  1127. break;
  1128. case GDScriptParser::Node::SUITE:
  1129. resolve_suite(static_cast<GDScriptParser::SuiteNode *>(p_node));
  1130. break;
  1131. case GDScriptParser::Node::VARIABLE:
  1132. resolve_variable(static_cast<GDScriptParser::VariableNode *>(p_node));
  1133. break;
  1134. case GDScriptParser::Node::WHILE:
  1135. resolve_while(static_cast<GDScriptParser::WhileNode *>(p_node));
  1136. break;
  1137. case GDScriptParser::Node::ANNOTATION:
  1138. resolve_annotation(static_cast<GDScriptParser::AnnotationNode *>(p_node));
  1139. break;
  1140. case GDScriptParser::Node::ASSERT:
  1141. resolve_assert(static_cast<GDScriptParser::AssertNode *>(p_node));
  1142. break;
  1143. case GDScriptParser::Node::MATCH:
  1144. resolve_match(static_cast<GDScriptParser::MatchNode *>(p_node));
  1145. break;
  1146. case GDScriptParser::Node::MATCH_BRANCH:
  1147. resolve_match_branch(static_cast<GDScriptParser::MatchBranchNode *>(p_node), nullptr);
  1148. break;
  1149. case GDScriptParser::Node::PARAMETER:
  1150. resolve_parameter(static_cast<GDScriptParser::ParameterNode *>(p_node));
  1151. break;
  1152. case GDScriptParser::Node::PATTERN:
  1153. resolve_match_pattern(static_cast<GDScriptParser::PatternNode *>(p_node), nullptr);
  1154. break;
  1155. case GDScriptParser::Node::RETURN:
  1156. resolve_return(static_cast<GDScriptParser::ReturnNode *>(p_node));
  1157. break;
  1158. case GDScriptParser::Node::TYPE:
  1159. resolve_datatype(static_cast<GDScriptParser::TypeNode *>(p_node));
  1160. break;
  1161. // Resolving expression is the same as reducing them.
  1162. case GDScriptParser::Node::ARRAY:
  1163. case GDScriptParser::Node::ASSIGNMENT:
  1164. case GDScriptParser::Node::AWAIT:
  1165. case GDScriptParser::Node::BINARY_OPERATOR:
  1166. case GDScriptParser::Node::CALL:
  1167. case GDScriptParser::Node::CAST:
  1168. case GDScriptParser::Node::DICTIONARY:
  1169. case GDScriptParser::Node::GET_NODE:
  1170. case GDScriptParser::Node::IDENTIFIER:
  1171. case GDScriptParser::Node::LAMBDA:
  1172. case GDScriptParser::Node::LITERAL:
  1173. case GDScriptParser::Node::PRELOAD:
  1174. case GDScriptParser::Node::SELF:
  1175. case GDScriptParser::Node::SUBSCRIPT:
  1176. case GDScriptParser::Node::TERNARY_OPERATOR:
  1177. case GDScriptParser::Node::UNARY_OPERATOR:
  1178. reduce_expression(static_cast<GDScriptParser::ExpressionNode *>(p_node), p_is_root);
  1179. break;
  1180. case GDScriptParser::Node::BREAK:
  1181. case GDScriptParser::Node::BREAKPOINT:
  1182. case GDScriptParser::Node::CONTINUE:
  1183. case GDScriptParser::Node::ENUM:
  1184. case GDScriptParser::Node::PASS:
  1185. case GDScriptParser::Node::SIGNAL:
  1186. // Nothing to do.
  1187. break;
  1188. }
  1189. }
  1190. void GDScriptAnalyzer::resolve_annotation(GDScriptParser::AnnotationNode *p_annotation) {
  1191. // TODO: Add second validation function for annotations, so they can use checked types.
  1192. }
  1193. void GDScriptAnalyzer::resolve_function_signature(GDScriptParser::FunctionNode *p_function, const GDScriptParser::Node *p_source) {
  1194. if (p_source == nullptr) {
  1195. p_source = p_function;
  1196. }
  1197. if (p_function->get_datatype().is_resolving()) {
  1198. push_error(vformat(R"(Could not resolve function "%s": Cyclic reference.)", p_function->identifier->name), p_source);
  1199. return;
  1200. }
  1201. if (p_function->resolved_signature) {
  1202. return;
  1203. }
  1204. p_function->resolved_signature = true;
  1205. GDScriptParser::FunctionNode *previous_function = parser->current_function;
  1206. parser->current_function = p_function;
  1207. GDScriptParser::DataType prev_datatype = p_function->get_datatype();
  1208. GDScriptParser::DataType resolving_datatype;
  1209. resolving_datatype.kind = GDScriptParser::DataType::RESOLVING;
  1210. p_function->set_datatype(resolving_datatype);
  1211. #ifdef TOOLS_ENABLED
  1212. int default_value_count = 0;
  1213. #endif // TOOLS_ENABLED
  1214. for (int i = 0; i < p_function->parameters.size(); i++) {
  1215. resolve_parameter(p_function->parameters[i]);
  1216. #ifdef DEBUG_ENABLED
  1217. if (p_function->parameters[i]->usages == 0 && !String(p_function->parameters[i]->identifier->name).begins_with("_")) {
  1218. parser->push_warning(p_function->parameters[i]->identifier, GDScriptWarning::UNUSED_PARAMETER, p_function->identifier->name, p_function->parameters[i]->identifier->name);
  1219. }
  1220. is_shadowing(p_function->parameters[i]->identifier, "function parameter");
  1221. #endif // DEBUG_ENABLED
  1222. #ifdef TOOLS_ENABLED
  1223. if (p_function->parameters[i]->default_value) {
  1224. default_value_count++;
  1225. if (p_function->parameters[i]->default_value->is_constant) {
  1226. p_function->default_arg_values.push_back(p_function->parameters[i]->default_value->reduced_value);
  1227. } else {
  1228. p_function->default_arg_values.push_back(Variant()); // Prevent shift.
  1229. }
  1230. }
  1231. #endif // TOOLS_ENABLED
  1232. }
  1233. if (p_function->identifier->name == GDScriptLanguage::get_singleton()->strings._init) {
  1234. // Constructor.
  1235. GDScriptParser::DataType return_type = parser->current_class->get_datatype();
  1236. return_type.is_meta_type = false;
  1237. p_function->set_datatype(return_type);
  1238. if (p_function->return_type) {
  1239. GDScriptParser::DataType declared_return = resolve_datatype(p_function->return_type);
  1240. if (declared_return.kind != GDScriptParser::DataType::BUILTIN || declared_return.builtin_type != Variant::NIL) {
  1241. push_error("Constructor cannot have an explicit return type.", p_function->return_type);
  1242. }
  1243. }
  1244. } else {
  1245. if (p_function->return_type != nullptr) {
  1246. p_function->set_datatype(resolve_datatype(p_function->return_type));
  1247. } else {
  1248. // In case the function is not typed, we can safely assume it's a Variant, so it's okay to mark as "inferred" here.
  1249. // It's not "undetected" to not mix up with unknown functions.
  1250. GDScriptParser::DataType return_type;
  1251. return_type.type_source = GDScriptParser::DataType::INFERRED;
  1252. return_type.kind = GDScriptParser::DataType::VARIANT;
  1253. p_function->set_datatype(return_type);
  1254. }
  1255. #ifdef TOOLS_ENABLED
  1256. // Check if the function signature matches the parent. If not it's an error since it breaks polymorphism.
  1257. // Not for the constructor which can vary in signature.
  1258. GDScriptParser::DataType base_type = parser->current_class->base_type;
  1259. GDScriptParser::DataType parent_return_type;
  1260. List<GDScriptParser::DataType> parameters_types;
  1261. int default_par_count = 0;
  1262. bool is_static = false;
  1263. bool is_vararg = false;
  1264. if (get_function_signature(p_function, false, base_type, p_function->identifier->name, parent_return_type, parameters_types, default_par_count, is_static, is_vararg)) {
  1265. bool valid = p_function->is_static == is_static;
  1266. valid = valid && parent_return_type == p_function->get_datatype();
  1267. int par_count_diff = p_function->parameters.size() - parameters_types.size();
  1268. valid = valid && par_count_diff >= 0;
  1269. valid = valid && default_value_count >= default_par_count + par_count_diff;
  1270. int i = 0;
  1271. for (const GDScriptParser::DataType &par_type : parameters_types) {
  1272. valid = valid && par_type == p_function->parameters[i++]->get_datatype();
  1273. }
  1274. if (!valid) {
  1275. // Compute parent signature as a string to show in the error message.
  1276. String parent_signature = p_function->identifier->name.operator String() + "(";
  1277. int j = 0;
  1278. for (const GDScriptParser::DataType &par_type : parameters_types) {
  1279. if (j > 0) {
  1280. parent_signature += ", ";
  1281. }
  1282. String parameter = par_type.to_string();
  1283. if (parameter == "null") {
  1284. parameter = "Variant";
  1285. }
  1286. parent_signature += parameter;
  1287. if (j == parameters_types.size() - default_par_count) {
  1288. parent_signature += " = default";
  1289. }
  1290. j++;
  1291. }
  1292. parent_signature += ") -> ";
  1293. const String return_type = parent_return_type.is_hard_type() ? parent_return_type.to_string() : "Variant";
  1294. if (return_type == "null") {
  1295. parent_signature += "void";
  1296. } else {
  1297. parent_signature += return_type;
  1298. }
  1299. push_error(vformat(R"(The function signature doesn't match the parent. Parent signature is "%s".)", parent_signature), p_function);
  1300. }
  1301. }
  1302. #endif // TOOLS_ENABLED
  1303. }
  1304. if (p_function->get_datatype().is_resolving()) {
  1305. p_function->set_datatype(prev_datatype);
  1306. }
  1307. parser->current_function = previous_function;
  1308. }
  1309. void GDScriptAnalyzer::resolve_function_body(GDScriptParser::FunctionNode *p_function) {
  1310. if (p_function->resolved_body) {
  1311. return;
  1312. }
  1313. p_function->resolved_body = true;
  1314. GDScriptParser::FunctionNode *previous_function = parser->current_function;
  1315. parser->current_function = p_function;
  1316. resolve_suite(p_function->body);
  1317. GDScriptParser::DataType return_type = p_function->body->get_datatype();
  1318. if (!p_function->get_datatype().is_hard_type() && return_type.is_set()) {
  1319. // Use the suite inferred type if return isn't explicitly set.
  1320. return_type.type_source = GDScriptParser::DataType::INFERRED;
  1321. p_function->set_datatype(p_function->body->get_datatype());
  1322. } else if (p_function->get_datatype().is_hard_type() && (p_function->get_datatype().kind != GDScriptParser::DataType::BUILTIN || p_function->get_datatype().builtin_type != Variant::NIL)) {
  1323. if (!p_function->body->has_return && p_function->identifier->name != GDScriptLanguage::get_singleton()->strings._init) {
  1324. push_error(R"(Not all code paths return a value.)", p_function);
  1325. }
  1326. }
  1327. parser->current_function = previous_function;
  1328. }
  1329. void GDScriptAnalyzer::decide_suite_type(GDScriptParser::Node *p_suite, GDScriptParser::Node *p_statement) {
  1330. if (p_statement == nullptr) {
  1331. return;
  1332. }
  1333. switch (p_statement->type) {
  1334. case GDScriptParser::Node::IF:
  1335. case GDScriptParser::Node::FOR:
  1336. case GDScriptParser::Node::MATCH:
  1337. case GDScriptParser::Node::PATTERN:
  1338. case GDScriptParser::Node::RETURN:
  1339. case GDScriptParser::Node::WHILE:
  1340. // Use return or nested suite type as this suite type.
  1341. if (p_suite->get_datatype().is_set() && (p_suite->get_datatype() != p_statement->get_datatype())) {
  1342. // Mixed types.
  1343. // TODO: This could use the common supertype instead.
  1344. p_suite->datatype.kind = GDScriptParser::DataType::VARIANT;
  1345. p_suite->datatype.type_source = GDScriptParser::DataType::UNDETECTED;
  1346. } else {
  1347. p_suite->set_datatype(p_statement->get_datatype());
  1348. p_suite->datatype.type_source = GDScriptParser::DataType::INFERRED;
  1349. }
  1350. break;
  1351. default:
  1352. break;
  1353. }
  1354. }
  1355. void GDScriptAnalyzer::resolve_suite(GDScriptParser::SuiteNode *p_suite) {
  1356. for (int i = 0; i < p_suite->statements.size(); i++) {
  1357. GDScriptParser::Node *stmt = p_suite->statements[i];
  1358. for (GDScriptParser::AnnotationNode *&annotation : stmt->annotations) {
  1359. annotation->apply(parser, stmt);
  1360. }
  1361. #ifdef DEBUG_ENABLED
  1362. HashSet<uint32_t> previously_ignored = parser->ignored_warning_codes;
  1363. for (uint32_t ignored_warning : stmt->ignored_warnings) {
  1364. parser->ignored_warning_codes.insert(ignored_warning);
  1365. }
  1366. #endif // DEBUG_ENABLED
  1367. resolve_node(stmt);
  1368. #ifdef DEBUG_ENABLED
  1369. parser->ignored_warning_codes = previously_ignored;
  1370. #endif // DEBUG_ENABLED
  1371. decide_suite_type(p_suite, stmt);
  1372. }
  1373. }
  1374. void GDScriptAnalyzer::resolve_if(GDScriptParser::IfNode *p_if) {
  1375. reduce_expression(p_if->condition);
  1376. resolve_suite(p_if->true_block);
  1377. p_if->set_datatype(p_if->true_block->get_datatype());
  1378. if (p_if->false_block != nullptr) {
  1379. resolve_suite(p_if->false_block);
  1380. decide_suite_type(p_if, p_if->false_block);
  1381. }
  1382. }
  1383. void GDScriptAnalyzer::resolve_for(GDScriptParser::ForNode *p_for) {
  1384. bool list_resolved = false;
  1385. // Optimize constant range() call to not allocate an array.
  1386. // Use int, Vector2i, Vector3i instead, which also can be used as range iterators.
  1387. if (p_for->list && p_for->list->type == GDScriptParser::Node::CALL) {
  1388. GDScriptParser::CallNode *call = static_cast<GDScriptParser::CallNode *>(p_for->list);
  1389. GDScriptParser::Node::Type callee_type = call->get_callee_type();
  1390. if (callee_type == GDScriptParser::Node::IDENTIFIER) {
  1391. GDScriptParser::IdentifierNode *callee = static_cast<GDScriptParser::IdentifierNode *>(call->callee);
  1392. if (callee->name == "range") {
  1393. list_resolved = true;
  1394. if (call->arguments.size() < 1) {
  1395. push_error(R"*(Invalid call for "range()" function. Expected at least 1 argument, none given.)*", call->callee);
  1396. } else if (call->arguments.size() > 3) {
  1397. push_error(vformat(R"*(Invalid call for "range()" function. Expected at most 3 arguments, %d given.)*", call->arguments.size()), call->callee);
  1398. } else {
  1399. // Now we can optimize it.
  1400. bool all_is_constant = true;
  1401. Vector<Variant> args;
  1402. args.resize(call->arguments.size());
  1403. for (int i = 0; i < call->arguments.size(); i++) {
  1404. reduce_expression(call->arguments[i]);
  1405. if (!call->arguments[i]->is_constant) {
  1406. all_is_constant = false;
  1407. } else if (all_is_constant) {
  1408. args.write[i] = call->arguments[i]->reduced_value;
  1409. }
  1410. GDScriptParser::DataType arg_type = call->arguments[i]->get_datatype();
  1411. if (!arg_type.is_variant()) {
  1412. if (arg_type.kind != GDScriptParser::DataType::BUILTIN) {
  1413. all_is_constant = false;
  1414. push_error(vformat(R"*(Invalid argument for "range()" call. Argument %d should be int or float but "%s" was given.)*", i + 1, arg_type.to_string()), call->arguments[i]);
  1415. } else if (arg_type.builtin_type != Variant::INT && arg_type.builtin_type != Variant::FLOAT) {
  1416. all_is_constant = false;
  1417. push_error(vformat(R"*(Invalid argument for "range()" call. Argument %d should be int or float but "%s" was given.)*", i + 1, arg_type.to_string()), call->arguments[i]);
  1418. }
  1419. }
  1420. }
  1421. Variant reduced;
  1422. if (all_is_constant) {
  1423. switch (args.size()) {
  1424. case 1:
  1425. reduced = (int32_t)args[0];
  1426. break;
  1427. case 2:
  1428. reduced = Vector2i(args[0], args[1]);
  1429. break;
  1430. case 3:
  1431. reduced = Vector3i(args[0], args[1], args[2]);
  1432. break;
  1433. }
  1434. p_for->list->is_constant = true;
  1435. p_for->list->reduced_value = reduced;
  1436. }
  1437. }
  1438. if (p_for->list->is_constant) {
  1439. p_for->list->set_datatype(type_from_variant(p_for->list->reduced_value, p_for->list));
  1440. } else {
  1441. GDScriptParser::DataType list_type;
  1442. list_type.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
  1443. list_type.kind = GDScriptParser::DataType::BUILTIN;
  1444. list_type.builtin_type = Variant::ARRAY;
  1445. p_for->list->set_datatype(list_type);
  1446. }
  1447. }
  1448. }
  1449. }
  1450. GDScriptParser::DataType variable_type;
  1451. if (list_resolved) {
  1452. variable_type.type_source = GDScriptParser::DataType::ANNOTATED_INFERRED;
  1453. variable_type.kind = GDScriptParser::DataType::BUILTIN;
  1454. variable_type.builtin_type = Variant::INT; // Can this ever be a float or something else?
  1455. p_for->variable->set_datatype(variable_type);
  1456. } else if (p_for->list) {
  1457. resolve_node(p_for->list, false);
  1458. if (p_for->list->datatype.has_container_element_type()) {
  1459. variable_type = p_for->list->datatype.get_container_element_type();
  1460. variable_type.type_source = GDScriptParser::DataType::ANNOTATED_INFERRED;
  1461. } else if (p_for->list->datatype.is_typed_container_type()) {
  1462. variable_type = p_for->list->datatype.get_typed_container_type();
  1463. variable_type.type_source = GDScriptParser::DataType::ANNOTATED_INFERRED;
  1464. } else {
  1465. // Last resort
  1466. // TODO: Must other cases be handled? Must we mark as unsafe?
  1467. variable_type.type_source = GDScriptParser::DataType::UNDETECTED;
  1468. variable_type.kind = GDScriptParser::DataType::VARIANT;
  1469. }
  1470. }
  1471. if (p_for->variable) {
  1472. p_for->variable->set_datatype(variable_type);
  1473. }
  1474. resolve_suite(p_for->loop);
  1475. p_for->set_datatype(p_for->loop->get_datatype());
  1476. #ifdef DEBUG_ENABLED
  1477. if (p_for->variable) {
  1478. is_shadowing(p_for->variable, R"("for" iterator variable)");
  1479. }
  1480. #endif
  1481. }
  1482. void GDScriptAnalyzer::resolve_while(GDScriptParser::WhileNode *p_while) {
  1483. resolve_node(p_while->condition, false);
  1484. resolve_suite(p_while->loop);
  1485. p_while->set_datatype(p_while->loop->get_datatype());
  1486. }
  1487. void GDScriptAnalyzer::resolve_variable(GDScriptParser::VariableNode *p_variable) {
  1488. GDScriptParser::DataType type;
  1489. type.kind = GDScriptParser::DataType::VARIANT; // By default.
  1490. GDScriptParser::DataType specified_type;
  1491. if (p_variable->datatype_specifier != nullptr) {
  1492. specified_type = resolve_datatype(p_variable->datatype_specifier);
  1493. specified_type.is_meta_type = false;
  1494. }
  1495. if (p_variable->initializer != nullptr) {
  1496. reduce_expression(p_variable->initializer);
  1497. if ((p_variable->infer_datatype || (p_variable->datatype_specifier != nullptr && specified_type.has_container_element_type())) && p_variable->initializer->type == GDScriptParser::Node::ARRAY) {
  1498. // Typed array.
  1499. GDScriptParser::ArrayNode *array = static_cast<GDScriptParser::ArrayNode *>(p_variable->initializer);
  1500. // Can only infer typed array if it has elements.
  1501. if ((p_variable->infer_datatype && array->elements.size() > 0) || p_variable->datatype_specifier != nullptr) {
  1502. update_array_literal_element_type(specified_type, array);
  1503. }
  1504. }
  1505. type = p_variable->initializer->get_datatype();
  1506. if (p_variable->infer_datatype) {
  1507. type.type_source = GDScriptParser::DataType::ANNOTATED_INFERRED;
  1508. if (type.has_no_type()) {
  1509. push_error(vformat(R"(Could not infer the type of the variable "%s" because the initial value does not have a set type.)", p_variable->identifier->name), p_variable->initializer);
  1510. } else if (type.is_variant()) {
  1511. push_error(vformat(R"(Could not infer the type of the variable "%s" because the initial value is a variant. Use explicit "Variant" type if this is intended.)", p_variable->identifier->name), p_variable->initializer);
  1512. } else if (type.kind == GDScriptParser::DataType::BUILTIN && type.builtin_type == Variant::NIL) {
  1513. push_error(vformat(R"(Could not infer the type of the variable "%s" because the initial value is "null".)", p_variable->identifier->name), p_variable->initializer);
  1514. }
  1515. } else {
  1516. type.type_source = GDScriptParser::DataType::INFERRED;
  1517. }
  1518. #ifdef DEBUG_ENABLED
  1519. if (p_variable->initializer->type == GDScriptParser::Node::CALL && type.kind == GDScriptParser::DataType::BUILTIN && type.builtin_type == Variant::NIL) {
  1520. parser->push_warning(p_variable->initializer, GDScriptWarning::VOID_ASSIGNMENT, static_cast<GDScriptParser::CallNode *>(p_variable->initializer)->function_name);
  1521. }
  1522. #endif
  1523. }
  1524. if (p_variable->datatype_specifier != nullptr) {
  1525. type = specified_type;
  1526. type.is_meta_type = false;
  1527. if (p_variable->initializer != nullptr) {
  1528. if (!is_type_compatible(type, p_variable->initializer->get_datatype(), true, p_variable->initializer)) {
  1529. // Try reverse test since it can be a masked subtype.
  1530. if (!is_type_compatible(p_variable->initializer->get_datatype(), type, true, p_variable->initializer)) {
  1531. push_error(vformat(R"(Value of type "%s" cannot be assigned to a variable of type "%s".)", p_variable->initializer->get_datatype().to_string(), type.to_string()), p_variable->initializer);
  1532. } else {
  1533. // TODO: Add warning.
  1534. mark_node_unsafe(p_variable->initializer);
  1535. p_variable->use_conversion_assign = true;
  1536. }
  1537. #ifdef DEBUG_ENABLED
  1538. } else if (type.builtin_type == Variant::INT && p_variable->initializer->get_datatype().builtin_type == Variant::FLOAT) {
  1539. parser->push_warning(p_variable->initializer, GDScriptWarning::NARROWING_CONVERSION);
  1540. #endif
  1541. }
  1542. if (p_variable->initializer->get_datatype().is_variant() && !type.is_variant()) {
  1543. // TODO: Warn unsafe assign.
  1544. mark_node_unsafe(p_variable->initializer);
  1545. p_variable->use_conversion_assign = true;
  1546. }
  1547. }
  1548. } else if (p_variable->infer_datatype) {
  1549. if (type.has_no_type()) {
  1550. push_error(vformat(R"(Cannot infer the type of variable "%s" because the initial value doesn't have a set type.)", p_variable->identifier->name), p_variable->identifier);
  1551. }
  1552. type.type_source = GDScriptParser::DataType::ANNOTATED_INFERRED;
  1553. }
  1554. type.is_constant = false;
  1555. p_variable->set_datatype(type);
  1556. #ifdef DEBUG_ENABLED
  1557. if (p_variable->usages == 0 && !String(p_variable->identifier->name).begins_with("_")) {
  1558. parser->push_warning(p_variable, GDScriptWarning::UNUSED_VARIABLE, p_variable->identifier->name);
  1559. } else if (p_variable->assignments == 0) {
  1560. parser->push_warning(p_variable, GDScriptWarning::UNASSIGNED_VARIABLE, p_variable->identifier->name);
  1561. }
  1562. is_shadowing(p_variable->identifier, "variable");
  1563. #endif
  1564. }
  1565. void GDScriptAnalyzer::resolve_constant(GDScriptParser::ConstantNode *p_constant) {
  1566. GDScriptParser::DataType type;
  1567. GDScriptParser::DataType explicit_type;
  1568. if (p_constant->datatype_specifier != nullptr) {
  1569. explicit_type = resolve_datatype(p_constant->datatype_specifier);
  1570. explicit_type.is_meta_type = false;
  1571. }
  1572. if (p_constant->initializer != nullptr) {
  1573. reduce_expression(p_constant->initializer);
  1574. if (p_constant->initializer->type == GDScriptParser::Node::ARRAY) {
  1575. GDScriptParser::ArrayNode *array = static_cast<GDScriptParser::ArrayNode *>(p_constant->initializer);
  1576. const_fold_array(array);
  1577. // Can only infer typed array if it has elements.
  1578. if (array->elements.size() > 0 || (p_constant->datatype_specifier != nullptr && explicit_type.has_container_element_type())) {
  1579. update_array_literal_element_type(explicit_type, array);
  1580. }
  1581. } else if (p_constant->initializer->type == GDScriptParser::Node::DICTIONARY) {
  1582. const_fold_dictionary(static_cast<GDScriptParser::DictionaryNode *>(p_constant->initializer));
  1583. }
  1584. if (!p_constant->initializer->is_constant) {
  1585. push_error(vformat(R"(Assigned value for constant "%s" isn't a constant expression.)", p_constant->identifier->name), p_constant->initializer);
  1586. }
  1587. type = p_constant->initializer->get_datatype();
  1588. #ifdef DEBUG_ENABLED
  1589. if (p_constant->initializer->type == GDScriptParser::Node::CALL && type.kind == GDScriptParser::DataType::BUILTIN && type.builtin_type == Variant::NIL) {
  1590. parser->push_warning(p_constant->initializer, GDScriptWarning::VOID_ASSIGNMENT, static_cast<GDScriptParser::CallNode *>(p_constant->initializer)->function_name);
  1591. }
  1592. #endif
  1593. }
  1594. if (p_constant->datatype_specifier != nullptr) {
  1595. if (!is_type_compatible(explicit_type, type, true)) {
  1596. push_error(vformat(R"(Assigned value for constant "%s" has type %s which is not compatible with defined type %s.)", p_constant->identifier->name, type.to_string(), explicit_type.to_string()), p_constant->initializer);
  1597. #ifdef DEBUG_ENABLED
  1598. } else if (explicit_type.builtin_type == Variant::INT && type.builtin_type == Variant::FLOAT) {
  1599. parser->push_warning(p_constant->initializer, GDScriptWarning::NARROWING_CONVERSION);
  1600. #endif
  1601. }
  1602. type = explicit_type;
  1603. } else if (p_constant->infer_datatype) {
  1604. if (type.has_no_type()) {
  1605. push_error(vformat(R"(Cannot infer the type of constant "%s" because the initial value doesn't have a set type.)", p_constant->identifier->name), p_constant->identifier);
  1606. }
  1607. type.type_source = GDScriptParser::DataType::ANNOTATED_INFERRED;
  1608. }
  1609. type.is_constant = true;
  1610. p_constant->set_datatype(type);
  1611. #ifdef DEBUG_ENABLED
  1612. if (p_constant->usages == 0) {
  1613. parser->push_warning(p_constant, GDScriptWarning::UNUSED_LOCAL_CONSTANT, p_constant->identifier->name);
  1614. }
  1615. is_shadowing(p_constant->identifier, "constant");
  1616. #endif
  1617. }
  1618. void GDScriptAnalyzer::resolve_assert(GDScriptParser::AssertNode *p_assert) {
  1619. reduce_expression(p_assert->condition);
  1620. if (p_assert->message != nullptr) {
  1621. reduce_expression(p_assert->message);
  1622. if (!p_assert->message->get_datatype().has_no_type() && (p_assert->message->get_datatype().kind != GDScriptParser::DataType::BUILTIN || p_assert->message->get_datatype().builtin_type != Variant::STRING)) {
  1623. push_error(R"(Expected string for assert error message.)", p_assert->message);
  1624. }
  1625. }
  1626. p_assert->set_datatype(p_assert->condition->get_datatype());
  1627. #ifdef DEBUG_ENABLED
  1628. if (p_assert->condition->is_constant) {
  1629. if (p_assert->condition->reduced_value.booleanize()) {
  1630. parser->push_warning(p_assert->condition, GDScriptWarning::ASSERT_ALWAYS_TRUE);
  1631. } else {
  1632. parser->push_warning(p_assert->condition, GDScriptWarning::ASSERT_ALWAYS_FALSE);
  1633. }
  1634. }
  1635. #endif
  1636. }
  1637. void GDScriptAnalyzer::resolve_match(GDScriptParser::MatchNode *p_match) {
  1638. reduce_expression(p_match->test);
  1639. for (int i = 0; i < p_match->branches.size(); i++) {
  1640. resolve_match_branch(p_match->branches[i], p_match->test);
  1641. decide_suite_type(p_match, p_match->branches[i]);
  1642. }
  1643. }
  1644. void GDScriptAnalyzer::resolve_match_branch(GDScriptParser::MatchBranchNode *p_match_branch, GDScriptParser::ExpressionNode *p_match_test) {
  1645. for (int i = 0; i < p_match_branch->patterns.size(); i++) {
  1646. resolve_match_pattern(p_match_branch->patterns[i], p_match_test);
  1647. }
  1648. resolve_suite(p_match_branch->block);
  1649. decide_suite_type(p_match_branch, p_match_branch->block);
  1650. }
  1651. void GDScriptAnalyzer::resolve_match_pattern(GDScriptParser::PatternNode *p_match_pattern, GDScriptParser::ExpressionNode *p_match_test) {
  1652. if (p_match_pattern == nullptr) {
  1653. return;
  1654. }
  1655. GDScriptParser::DataType result;
  1656. switch (p_match_pattern->pattern_type) {
  1657. case GDScriptParser::PatternNode::PT_LITERAL:
  1658. if (p_match_pattern->literal) {
  1659. reduce_literal(p_match_pattern->literal);
  1660. result = p_match_pattern->literal->get_datatype();
  1661. }
  1662. break;
  1663. case GDScriptParser::PatternNode::PT_EXPRESSION:
  1664. if (p_match_pattern->expression) {
  1665. reduce_expression(p_match_pattern->expression);
  1666. if (!p_match_pattern->expression->is_constant) {
  1667. push_error(R"(Expression in match pattern must be a constant.)", p_match_pattern->expression);
  1668. }
  1669. result = p_match_pattern->expression->get_datatype();
  1670. }
  1671. break;
  1672. case GDScriptParser::PatternNode::PT_BIND:
  1673. if (p_match_test != nullptr) {
  1674. result = p_match_test->get_datatype();
  1675. } else {
  1676. result.kind = GDScriptParser::DataType::VARIANT;
  1677. }
  1678. p_match_pattern->bind->set_datatype(result);
  1679. #ifdef DEBUG_ENABLED
  1680. is_shadowing(p_match_pattern->bind, "pattern bind");
  1681. if (p_match_pattern->bind->usages == 0 && !String(p_match_pattern->bind->name).begins_with("_")) {
  1682. parser->push_warning(p_match_pattern->bind, GDScriptWarning::UNUSED_VARIABLE, p_match_pattern->bind->name);
  1683. }
  1684. #endif
  1685. break;
  1686. case GDScriptParser::PatternNode::PT_ARRAY:
  1687. for (int i = 0; i < p_match_pattern->array.size(); i++) {
  1688. resolve_match_pattern(p_match_pattern->array[i], nullptr);
  1689. decide_suite_type(p_match_pattern, p_match_pattern->array[i]);
  1690. }
  1691. result = p_match_pattern->get_datatype();
  1692. break;
  1693. case GDScriptParser::PatternNode::PT_DICTIONARY:
  1694. for (int i = 0; i < p_match_pattern->dictionary.size(); i++) {
  1695. if (p_match_pattern->dictionary[i].key) {
  1696. reduce_expression(p_match_pattern->dictionary[i].key);
  1697. if (!p_match_pattern->dictionary[i].key->is_constant) {
  1698. push_error(R"(Expression in dictionary pattern key must be a constant.)", p_match_pattern->dictionary[i].key);
  1699. }
  1700. }
  1701. if (p_match_pattern->dictionary[i].value_pattern) {
  1702. resolve_match_pattern(p_match_pattern->dictionary[i].value_pattern, nullptr);
  1703. decide_suite_type(p_match_pattern, p_match_pattern->dictionary[i].value_pattern);
  1704. }
  1705. }
  1706. result = p_match_pattern->get_datatype();
  1707. break;
  1708. case GDScriptParser::PatternNode::PT_WILDCARD:
  1709. case GDScriptParser::PatternNode::PT_REST:
  1710. result.kind = GDScriptParser::DataType::VARIANT;
  1711. break;
  1712. }
  1713. p_match_pattern->set_datatype(result);
  1714. }
  1715. void GDScriptAnalyzer::resolve_parameter(GDScriptParser::ParameterNode *p_parameter) {
  1716. GDScriptParser::DataType result;
  1717. result.kind = GDScriptParser::DataType::VARIANT;
  1718. if (p_parameter->default_value != nullptr) {
  1719. reduce_expression(p_parameter->default_value);
  1720. result = p_parameter->default_value->get_datatype();
  1721. if (p_parameter->infer_datatype) {
  1722. result.type_source = GDScriptParser::DataType::ANNOTATED_INFERRED;
  1723. } else {
  1724. result.type_source = GDScriptParser::DataType::INFERRED;
  1725. }
  1726. }
  1727. if (p_parameter->datatype_specifier != nullptr) {
  1728. result = resolve_datatype(p_parameter->datatype_specifier);
  1729. result.is_meta_type = false;
  1730. if (p_parameter->default_value != nullptr) {
  1731. if (!is_type_compatible(result, p_parameter->default_value->get_datatype())) {
  1732. push_error(vformat(R"(Type of default value for parameter "%s" (%s) is not compatible with parameter type (%s).)", p_parameter->identifier->name, p_parameter->default_value->get_datatype().to_string(), p_parameter->datatype_specifier->get_datatype().to_string()), p_parameter->default_value);
  1733. } else if (p_parameter->default_value->get_datatype().is_variant()) {
  1734. mark_node_unsafe(p_parameter);
  1735. }
  1736. }
  1737. }
  1738. if (result.builtin_type == Variant::Type::NIL && result.type_source == GDScriptParser::DataType::ANNOTATED_INFERRED && p_parameter->datatype_specifier == nullptr) {
  1739. push_error(vformat(R"(Could not infer the type of the variable "%s" because the initial value is "null".)", p_parameter->identifier->name), p_parameter->default_value);
  1740. }
  1741. result.is_constant = false;
  1742. p_parameter->set_datatype(result);
  1743. }
  1744. void GDScriptAnalyzer::resolve_return(GDScriptParser::ReturnNode *p_return) {
  1745. GDScriptParser::DataType result;
  1746. GDScriptParser::DataType expected_type;
  1747. bool has_expected_type = false;
  1748. if (parser->current_function != nullptr) {
  1749. expected_type = parser->current_function->get_datatype();
  1750. has_expected_type = true;
  1751. }
  1752. if (p_return->return_value != nullptr) {
  1753. reduce_expression(p_return->return_value);
  1754. if (p_return->return_value->type == GDScriptParser::Node::ARRAY) {
  1755. // Check if assigned value is an array literal, so we can make it a typed array too if appropriate.
  1756. if (has_expected_type && expected_type.has_container_element_type() && p_return->return_value->type == GDScriptParser::Node::ARRAY) {
  1757. update_array_literal_element_type(expected_type, static_cast<GDScriptParser::ArrayNode *>(p_return->return_value));
  1758. }
  1759. }
  1760. result = p_return->return_value->get_datatype();
  1761. } else {
  1762. // Return type is null by default.
  1763. result.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
  1764. result.kind = GDScriptParser::DataType::BUILTIN;
  1765. result.builtin_type = Variant::NIL;
  1766. result.is_constant = true;
  1767. }
  1768. if (has_expected_type) {
  1769. expected_type.is_meta_type = false;
  1770. if (expected_type.is_hard_type()) {
  1771. if (!is_type_compatible(expected_type, result)) {
  1772. // Try other way. Okay but not safe.
  1773. if (!is_type_compatible(result, expected_type)) {
  1774. push_error(vformat(R"(Cannot return value of type "%s" because the function return type is "%s".)", result.to_string(), expected_type.to_string()), p_return);
  1775. } else {
  1776. // TODO: Add warning.
  1777. mark_node_unsafe(p_return);
  1778. }
  1779. #ifdef DEBUG_ENABLED
  1780. } else if (expected_type.builtin_type == Variant::INT && result.builtin_type == Variant::FLOAT) {
  1781. parser->push_warning(p_return, GDScriptWarning::NARROWING_CONVERSION);
  1782. } else if (result.is_variant()) {
  1783. mark_node_unsafe(p_return);
  1784. #endif
  1785. }
  1786. }
  1787. }
  1788. p_return->set_datatype(result);
  1789. }
  1790. void GDScriptAnalyzer::reduce_expression(GDScriptParser::ExpressionNode *p_expression, bool p_is_root) {
  1791. // This one makes some magic happen.
  1792. if (p_expression == nullptr) {
  1793. return;
  1794. }
  1795. if (p_expression->reduced) {
  1796. // Don't do this more than once.
  1797. return;
  1798. }
  1799. p_expression->reduced = true;
  1800. switch (p_expression->type) {
  1801. case GDScriptParser::Node::ARRAY:
  1802. reduce_array(static_cast<GDScriptParser::ArrayNode *>(p_expression));
  1803. break;
  1804. case GDScriptParser::Node::ASSIGNMENT:
  1805. reduce_assignment(static_cast<GDScriptParser::AssignmentNode *>(p_expression));
  1806. break;
  1807. case GDScriptParser::Node::AWAIT:
  1808. reduce_await(static_cast<GDScriptParser::AwaitNode *>(p_expression));
  1809. break;
  1810. case GDScriptParser::Node::BINARY_OPERATOR:
  1811. reduce_binary_op(static_cast<GDScriptParser::BinaryOpNode *>(p_expression));
  1812. break;
  1813. case GDScriptParser::Node::CALL:
  1814. reduce_call(static_cast<GDScriptParser::CallNode *>(p_expression), false, p_is_root);
  1815. break;
  1816. case GDScriptParser::Node::CAST:
  1817. reduce_cast(static_cast<GDScriptParser::CastNode *>(p_expression));
  1818. break;
  1819. case GDScriptParser::Node::DICTIONARY:
  1820. reduce_dictionary(static_cast<GDScriptParser::DictionaryNode *>(p_expression));
  1821. break;
  1822. case GDScriptParser::Node::GET_NODE:
  1823. reduce_get_node(static_cast<GDScriptParser::GetNodeNode *>(p_expression));
  1824. break;
  1825. case GDScriptParser::Node::IDENTIFIER:
  1826. reduce_identifier(static_cast<GDScriptParser::IdentifierNode *>(p_expression));
  1827. break;
  1828. case GDScriptParser::Node::LAMBDA:
  1829. reduce_lambda(static_cast<GDScriptParser::LambdaNode *>(p_expression));
  1830. break;
  1831. case GDScriptParser::Node::LITERAL:
  1832. reduce_literal(static_cast<GDScriptParser::LiteralNode *>(p_expression));
  1833. break;
  1834. case GDScriptParser::Node::PRELOAD:
  1835. reduce_preload(static_cast<GDScriptParser::PreloadNode *>(p_expression));
  1836. break;
  1837. case GDScriptParser::Node::SELF:
  1838. reduce_self(static_cast<GDScriptParser::SelfNode *>(p_expression));
  1839. break;
  1840. case GDScriptParser::Node::SUBSCRIPT:
  1841. reduce_subscript(static_cast<GDScriptParser::SubscriptNode *>(p_expression));
  1842. break;
  1843. case GDScriptParser::Node::TERNARY_OPERATOR:
  1844. reduce_ternary_op(static_cast<GDScriptParser::TernaryOpNode *>(p_expression));
  1845. break;
  1846. case GDScriptParser::Node::UNARY_OPERATOR:
  1847. reduce_unary_op(static_cast<GDScriptParser::UnaryOpNode *>(p_expression));
  1848. break;
  1849. // Non-expressions. Here only to make sure new nodes aren't forgotten.
  1850. case GDScriptParser::Node::NONE:
  1851. case GDScriptParser::Node::ANNOTATION:
  1852. case GDScriptParser::Node::ASSERT:
  1853. case GDScriptParser::Node::BREAK:
  1854. case GDScriptParser::Node::BREAKPOINT:
  1855. case GDScriptParser::Node::CLASS:
  1856. case GDScriptParser::Node::CONSTANT:
  1857. case GDScriptParser::Node::CONTINUE:
  1858. case GDScriptParser::Node::ENUM:
  1859. case GDScriptParser::Node::FOR:
  1860. case GDScriptParser::Node::FUNCTION:
  1861. case GDScriptParser::Node::IF:
  1862. case GDScriptParser::Node::MATCH:
  1863. case GDScriptParser::Node::MATCH_BRANCH:
  1864. case GDScriptParser::Node::PARAMETER:
  1865. case GDScriptParser::Node::PASS:
  1866. case GDScriptParser::Node::PATTERN:
  1867. case GDScriptParser::Node::RETURN:
  1868. case GDScriptParser::Node::SIGNAL:
  1869. case GDScriptParser::Node::SUITE:
  1870. case GDScriptParser::Node::TYPE:
  1871. case GDScriptParser::Node::VARIABLE:
  1872. case GDScriptParser::Node::WHILE:
  1873. ERR_FAIL_MSG("Reaching unreachable case");
  1874. }
  1875. }
  1876. void GDScriptAnalyzer::reduce_array(GDScriptParser::ArrayNode *p_array) {
  1877. for (int i = 0; i < p_array->elements.size(); i++) {
  1878. GDScriptParser::ExpressionNode *element = p_array->elements[i];
  1879. reduce_expression(element);
  1880. }
  1881. // It's array in any case.
  1882. GDScriptParser::DataType arr_type;
  1883. arr_type.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
  1884. arr_type.kind = GDScriptParser::DataType::BUILTIN;
  1885. arr_type.builtin_type = Variant::ARRAY;
  1886. arr_type.is_constant = true;
  1887. p_array->set_datatype(arr_type);
  1888. }
  1889. // When an array literal is stored (or passed as function argument) to a typed context, we then assume the array is typed.
  1890. // This function determines which type is that (if any).
  1891. void GDScriptAnalyzer::update_array_literal_element_type(const GDScriptParser::DataType &p_base_type, GDScriptParser::ArrayNode *p_array_literal) {
  1892. GDScriptParser::DataType array_type = p_array_literal->get_datatype();
  1893. if (p_array_literal->elements.size() == 0) {
  1894. // Empty array literal, just make the same type as the storage.
  1895. array_type.set_container_element_type(p_base_type.get_container_element_type());
  1896. } else {
  1897. // Check if elements match.
  1898. bool all_same_type = true;
  1899. bool all_have_type = true;
  1900. GDScriptParser::DataType element_type;
  1901. for (int i = 0; i < p_array_literal->elements.size(); i++) {
  1902. if (i == 0) {
  1903. element_type = p_array_literal->elements[0]->get_datatype();
  1904. } else {
  1905. GDScriptParser::DataType this_element_type = p_array_literal->elements[i]->get_datatype();
  1906. if (this_element_type.has_no_type()) {
  1907. all_same_type = false;
  1908. all_have_type = false;
  1909. break;
  1910. } else if (element_type != this_element_type) {
  1911. if (!is_type_compatible(element_type, this_element_type, false)) {
  1912. if (is_type_compatible(this_element_type, element_type, false)) {
  1913. // This element is a super-type to the previous type, so we use the super-type.
  1914. element_type = this_element_type;
  1915. } else {
  1916. // It's incompatible.
  1917. all_same_type = false;
  1918. break;
  1919. }
  1920. }
  1921. }
  1922. }
  1923. }
  1924. if (all_same_type) {
  1925. element_type.is_constant = false;
  1926. array_type.set_container_element_type(element_type);
  1927. } else if (all_have_type) {
  1928. push_error(vformat(R"(Variant array is not compatible with an array of type "%s".)", p_base_type.get_container_element_type().to_string()), p_array_literal);
  1929. }
  1930. }
  1931. // Update the type on the value itself.
  1932. p_array_literal->set_datatype(array_type);
  1933. }
  1934. void GDScriptAnalyzer::reduce_assignment(GDScriptParser::AssignmentNode *p_assignment) {
  1935. reduce_expression(p_assignment->assignee);
  1936. reduce_expression(p_assignment->assigned_value);
  1937. if (p_assignment->assigned_value == nullptr || p_assignment->assignee == nullptr) {
  1938. return;
  1939. }
  1940. GDScriptParser::DataType assignee_type = p_assignment->assignee->get_datatype();
  1941. // Check if assigned value is an array literal, so we can make it a typed array too if appropriate.
  1942. if (assignee_type.has_container_element_type() && p_assignment->assigned_value->type == GDScriptParser::Node::ARRAY) {
  1943. update_array_literal_element_type(assignee_type, static_cast<GDScriptParser::ArrayNode *>(p_assignment->assigned_value));
  1944. }
  1945. GDScriptParser::DataType assigned_value_type = p_assignment->assigned_value->get_datatype();
  1946. if (assignee_type.is_constant) {
  1947. push_error("Cannot assign a new value to a constant.", p_assignment->assignee);
  1948. }
  1949. bool compatible = true;
  1950. GDScriptParser::DataType op_type = assigned_value_type;
  1951. if (p_assignment->operation != GDScriptParser::AssignmentNode::OP_NONE) {
  1952. op_type = get_operation_type(p_assignment->variant_op, assignee_type, assigned_value_type, compatible, p_assignment->assigned_value);
  1953. }
  1954. p_assignment->set_datatype(op_type);
  1955. if (!assignee_type.is_variant() && assigned_value_type.is_hard_type()) {
  1956. if (compatible) {
  1957. compatible = is_type_compatible(assignee_type, op_type, true, p_assignment->assigned_value);
  1958. if (!compatible) {
  1959. if (assignee_type.is_hard_type()) {
  1960. // Try reverse test since it can be a masked subtype.
  1961. if (!is_type_compatible(op_type, assignee_type, true, p_assignment->assigned_value)) {
  1962. push_error(vformat(R"(Cannot assign a value of type "%s" to a target of type "%s".)", assigned_value_type.to_string(), assignee_type.to_string()), p_assignment->assigned_value);
  1963. } else {
  1964. // TODO: Add warning.
  1965. mark_node_unsafe(p_assignment);
  1966. p_assignment->use_conversion_assign = true;
  1967. }
  1968. } else {
  1969. // TODO: Warning in this case.
  1970. mark_node_unsafe(p_assignment);
  1971. }
  1972. }
  1973. } else {
  1974. push_error(vformat(R"(Invalid operands "%s" and "%s" for assignment operator.)", assignee_type.to_string(), assigned_value_type.to_string()), p_assignment);
  1975. }
  1976. }
  1977. if (assignee_type.has_no_type() || assigned_value_type.is_variant()) {
  1978. mark_node_unsafe(p_assignment);
  1979. if (assignee_type.is_hard_type() && !assignee_type.is_variant()) {
  1980. p_assignment->use_conversion_assign = true;
  1981. }
  1982. }
  1983. if (p_assignment->assignee->type == GDScriptParser::Node::IDENTIFIER) {
  1984. // Change source type so it's not wrongly detected later.
  1985. GDScriptParser::IdentifierNode *identifier = static_cast<GDScriptParser::IdentifierNode *>(p_assignment->assignee);
  1986. switch (identifier->source) {
  1987. case GDScriptParser::IdentifierNode::MEMBER_VARIABLE: {
  1988. GDScriptParser::DataType id_type = identifier->variable_source->get_datatype();
  1989. if (!id_type.is_hard_type()) {
  1990. id_type.kind = GDScriptParser::DataType::VARIANT;
  1991. id_type.type_source = GDScriptParser::DataType::UNDETECTED;
  1992. identifier->variable_source->set_datatype(id_type);
  1993. }
  1994. } break;
  1995. case GDScriptParser::IdentifierNode::FUNCTION_PARAMETER: {
  1996. GDScriptParser::DataType id_type = identifier->parameter_source->get_datatype();
  1997. if (!id_type.is_hard_type()) {
  1998. id_type.kind = GDScriptParser::DataType::VARIANT;
  1999. id_type.type_source = GDScriptParser::DataType::UNDETECTED;
  2000. identifier->parameter_source->set_datatype(id_type);
  2001. }
  2002. } break;
  2003. case GDScriptParser::IdentifierNode::LOCAL_VARIABLE: {
  2004. GDScriptParser::DataType id_type = identifier->variable_source->get_datatype();
  2005. if (!id_type.is_hard_type()) {
  2006. id_type.kind = GDScriptParser::DataType::VARIANT;
  2007. id_type.type_source = GDScriptParser::DataType::UNDETECTED;
  2008. identifier->variable_source->set_datatype(id_type);
  2009. }
  2010. } break;
  2011. case GDScriptParser::IdentifierNode::LOCAL_ITERATOR: {
  2012. GDScriptParser::DataType id_type = identifier->bind_source->get_datatype();
  2013. if (!id_type.is_hard_type()) {
  2014. id_type.kind = GDScriptParser::DataType::VARIANT;
  2015. id_type.type_source = GDScriptParser::DataType::UNDETECTED;
  2016. identifier->variable_source->set_datatype(id_type);
  2017. }
  2018. } break;
  2019. default:
  2020. // Nothing to do.
  2021. break;
  2022. }
  2023. }
  2024. #ifdef DEBUG_ENABLED
  2025. if (p_assignment->assigned_value->type == GDScriptParser::Node::CALL && assigned_value_type.kind == GDScriptParser::DataType::BUILTIN && assigned_value_type.builtin_type == Variant::NIL) {
  2026. parser->push_warning(p_assignment->assigned_value, GDScriptWarning::VOID_ASSIGNMENT, static_cast<GDScriptParser::CallNode *>(p_assignment->assigned_value)->function_name);
  2027. } else if (assignee_type.is_hard_type() && assignee_type.builtin_type == Variant::INT && assigned_value_type.builtin_type == Variant::FLOAT) {
  2028. parser->push_warning(p_assignment->assigned_value, GDScriptWarning::NARROWING_CONVERSION);
  2029. }
  2030. #endif
  2031. }
  2032. void GDScriptAnalyzer::reduce_await(GDScriptParser::AwaitNode *p_await) {
  2033. if (p_await->to_await == nullptr) {
  2034. GDScriptParser::DataType await_type;
  2035. await_type.kind = GDScriptParser::DataType::VARIANT;
  2036. p_await->set_datatype(await_type);
  2037. return;
  2038. }
  2039. GDScriptParser::DataType awaiting_type;
  2040. if (p_await->to_await->type == GDScriptParser::Node::CALL) {
  2041. reduce_call(static_cast<GDScriptParser::CallNode *>(p_await->to_await), true);
  2042. awaiting_type = p_await->to_await->get_datatype();
  2043. } else {
  2044. reduce_expression(p_await->to_await);
  2045. }
  2046. if (p_await->to_await->is_constant) {
  2047. p_await->is_constant = p_await->to_await->is_constant;
  2048. p_await->reduced_value = p_await->to_await->reduced_value;
  2049. awaiting_type = p_await->to_await->get_datatype();
  2050. } else {
  2051. awaiting_type.kind = GDScriptParser::DataType::VARIANT;
  2052. awaiting_type.type_source = GDScriptParser::DataType::UNDETECTED;
  2053. }
  2054. p_await->set_datatype(awaiting_type);
  2055. #ifdef DEBUG_ENABLED
  2056. awaiting_type = p_await->to_await->get_datatype();
  2057. if (!(awaiting_type.has_no_type() || awaiting_type.is_coroutine || awaiting_type.builtin_type == Variant::SIGNAL)) {
  2058. parser->push_warning(p_await, GDScriptWarning::REDUNDANT_AWAIT);
  2059. }
  2060. #endif
  2061. }
  2062. void GDScriptAnalyzer::reduce_binary_op(GDScriptParser::BinaryOpNode *p_binary_op) {
  2063. reduce_expression(p_binary_op->left_operand);
  2064. if (p_binary_op->operation == GDScriptParser::BinaryOpNode::OP_TYPE_TEST && p_binary_op->right_operand && p_binary_op->right_operand->type == GDScriptParser::Node::IDENTIFIER) {
  2065. reduce_identifier(static_cast<GDScriptParser::IdentifierNode *>(p_binary_op->right_operand), true);
  2066. } else {
  2067. reduce_expression(p_binary_op->right_operand);
  2068. }
  2069. // TODO: Right operand must be a valid type with the `is` operator. Need to check here.
  2070. GDScriptParser::DataType left_type;
  2071. if (p_binary_op->left_operand) {
  2072. left_type = p_binary_op->left_operand->get_datatype();
  2073. }
  2074. GDScriptParser::DataType right_type;
  2075. if (p_binary_op->right_operand) {
  2076. right_type = p_binary_op->right_operand->get_datatype();
  2077. }
  2078. if (!left_type.is_set() || !right_type.is_set()) {
  2079. return;
  2080. }
  2081. #ifdef DEBUG_ENABLED
  2082. if (p_binary_op->variant_op == Variant::OP_DIVIDE && left_type.builtin_type == Variant::INT && right_type.builtin_type == Variant::INT) {
  2083. parser->push_warning(p_binary_op, GDScriptWarning::INTEGER_DIVISION);
  2084. }
  2085. #endif
  2086. if (p_binary_op->left_operand->is_constant && p_binary_op->right_operand->is_constant) {
  2087. p_binary_op->is_constant = true;
  2088. if (p_binary_op->variant_op < Variant::OP_MAX) {
  2089. bool valid = false;
  2090. Variant::evaluate(p_binary_op->variant_op, p_binary_op->left_operand->reduced_value, p_binary_op->right_operand->reduced_value, p_binary_op->reduced_value, valid);
  2091. if (!valid) {
  2092. if (p_binary_op->reduced_value.get_type() == Variant::STRING) {
  2093. push_error(vformat(R"(%s in operator %s.)", p_binary_op->reduced_value, Variant::get_operator_name(p_binary_op->variant_op)), p_binary_op);
  2094. } else {
  2095. push_error(vformat(R"(Invalid operands to operator %s, %s and %s.)",
  2096. Variant::get_operator_name(p_binary_op->variant_op),
  2097. Variant::get_type_name(p_binary_op->left_operand->reduced_value.get_type()),
  2098. Variant::get_type_name(p_binary_op->right_operand->reduced_value.get_type())),
  2099. p_binary_op);
  2100. }
  2101. }
  2102. } else {
  2103. if (p_binary_op->operation == GDScriptParser::BinaryOpNode::OP_TYPE_TEST) {
  2104. GDScriptParser::DataType test_type = right_type;
  2105. test_type.is_meta_type = false;
  2106. if (!is_type_compatible(test_type, left_type, false)) {
  2107. push_error(vformat(R"(Expression is of type "%s" so it can't be of type "%s".)"), p_binary_op->left_operand);
  2108. p_binary_op->reduced_value = false;
  2109. } else {
  2110. p_binary_op->reduced_value = true;
  2111. }
  2112. } else {
  2113. ERR_PRINT("Parser bug: unknown binary operation.");
  2114. }
  2115. }
  2116. p_binary_op->set_datatype(type_from_variant(p_binary_op->reduced_value, p_binary_op));
  2117. return;
  2118. }
  2119. GDScriptParser::DataType result;
  2120. if (left_type.is_variant() || right_type.is_variant()) {
  2121. // Cannot infer type because one operand can be anything.
  2122. result.kind = GDScriptParser::DataType::VARIANT;
  2123. mark_node_unsafe(p_binary_op);
  2124. } else {
  2125. if (p_binary_op->variant_op < Variant::OP_MAX) {
  2126. bool valid = false;
  2127. result = get_operation_type(p_binary_op->variant_op, left_type, right_type, valid, p_binary_op);
  2128. if (!valid) {
  2129. push_error(vformat(R"(Invalid operands "%s" and "%s" for "%s" operator.)", left_type.to_string(), right_type.to_string(), Variant::get_operator_name(p_binary_op->variant_op)), p_binary_op);
  2130. }
  2131. } else {
  2132. if (p_binary_op->operation == GDScriptParser::BinaryOpNode::OP_TYPE_TEST) {
  2133. GDScriptParser::DataType test_type = right_type;
  2134. test_type.is_meta_type = false;
  2135. if (!is_type_compatible(test_type, left_type, false)) {
  2136. // Test reverse as well to consider for subtypes.
  2137. if (!is_type_compatible(left_type, test_type, false)) {
  2138. if (left_type.is_hard_type()) {
  2139. push_error(vformat(R"(Expression is of type "%s" so it can't be of type "%s".)", left_type.to_string(), test_type.to_string()), p_binary_op->left_operand);
  2140. } else {
  2141. // TODO: Warning.
  2142. mark_node_unsafe(p_binary_op);
  2143. }
  2144. }
  2145. }
  2146. // "is" operator is always a boolean anyway.
  2147. result.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
  2148. result.kind = GDScriptParser::DataType::BUILTIN;
  2149. result.builtin_type = Variant::BOOL;
  2150. } else {
  2151. ERR_PRINT("Parser bug: unknown binary operation.");
  2152. }
  2153. }
  2154. }
  2155. p_binary_op->set_datatype(result);
  2156. }
  2157. void GDScriptAnalyzer::reduce_call(GDScriptParser::CallNode *p_call, bool p_is_await, bool p_is_root) {
  2158. bool all_is_constant = true;
  2159. HashMap<int, GDScriptParser::ArrayNode *> arrays; // For array literal to potentially type when passing.
  2160. for (int i = 0; i < p_call->arguments.size(); i++) {
  2161. reduce_expression(p_call->arguments[i]);
  2162. if (p_call->arguments[i]->type == GDScriptParser::Node::ARRAY) {
  2163. arrays[i] = static_cast<GDScriptParser::ArrayNode *>(p_call->arguments[i]);
  2164. }
  2165. all_is_constant = all_is_constant && p_call->arguments[i]->is_constant;
  2166. }
  2167. GDScriptParser::Node::Type callee_type = p_call->get_callee_type();
  2168. GDScriptParser::DataType call_type;
  2169. if (!p_call->is_super && callee_type == GDScriptParser::Node::IDENTIFIER) {
  2170. // Call to name directly.
  2171. StringName function_name = p_call->function_name;
  2172. Variant::Type builtin_type = GDScriptParser::get_builtin_type(function_name);
  2173. if (builtin_type < Variant::VARIANT_MAX) {
  2174. // Is a builtin constructor.
  2175. call_type.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
  2176. call_type.kind = GDScriptParser::DataType::BUILTIN;
  2177. call_type.builtin_type = builtin_type;
  2178. if (builtin_type == Variant::OBJECT) {
  2179. call_type.kind = GDScriptParser::DataType::NATIVE;
  2180. call_type.native_type = function_name; // "Object".
  2181. }
  2182. bool safe_to_fold = true;
  2183. switch (builtin_type) {
  2184. // Those are stored by reference so not suited for compile-time construction.
  2185. // Because in this case they would be the same reference in all constructed values.
  2186. case Variant::OBJECT:
  2187. case Variant::DICTIONARY:
  2188. case Variant::ARRAY:
  2189. case Variant::PACKED_BYTE_ARRAY:
  2190. case Variant::PACKED_INT32_ARRAY:
  2191. case Variant::PACKED_INT64_ARRAY:
  2192. case Variant::PACKED_FLOAT32_ARRAY:
  2193. case Variant::PACKED_FLOAT64_ARRAY:
  2194. case Variant::PACKED_STRING_ARRAY:
  2195. case Variant::PACKED_VECTOR2_ARRAY:
  2196. case Variant::PACKED_VECTOR3_ARRAY:
  2197. case Variant::PACKED_COLOR_ARRAY:
  2198. safe_to_fold = false;
  2199. break;
  2200. default:
  2201. break;
  2202. }
  2203. if (all_is_constant && safe_to_fold) {
  2204. // Construct here.
  2205. Vector<const Variant *> args;
  2206. for (int i = 0; i < p_call->arguments.size(); i++) {
  2207. args.push_back(&(p_call->arguments[i]->reduced_value));
  2208. }
  2209. Callable::CallError err;
  2210. Variant value;
  2211. Variant::construct(builtin_type, value, (const Variant **)args.ptr(), args.size(), err);
  2212. switch (err.error) {
  2213. case Callable::CallError::CALL_ERROR_INVALID_ARGUMENT:
  2214. push_error(vformat(R"(Invalid argument for %s constructor: argument %d should be %s but is %s.)", Variant::get_type_name(builtin_type), err.argument + 1,
  2215. Variant::get_type_name(Variant::Type(err.expected)), p_call->arguments[err.argument]->get_datatype().to_string()),
  2216. p_call->arguments[err.argument]);
  2217. break;
  2218. case Callable::CallError::CALL_ERROR_INVALID_METHOD: {
  2219. String signature = Variant::get_type_name(builtin_type) + "(";
  2220. for (int i = 0; i < p_call->arguments.size(); i++) {
  2221. if (i > 0) {
  2222. signature += ", ";
  2223. }
  2224. signature += p_call->arguments[i]->get_datatype().to_string();
  2225. }
  2226. signature += ")";
  2227. push_error(vformat(R"(No constructor of "%s" matches the signature "%s".)", Variant::get_type_name(builtin_type), signature), p_call->callee);
  2228. } break;
  2229. case Callable::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS:
  2230. push_error(vformat(R"(Too many arguments for %s constructor. Received %d but expected %d.)", Variant::get_type_name(builtin_type), p_call->arguments.size(), err.expected), p_call);
  2231. break;
  2232. case Callable::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS:
  2233. push_error(vformat(R"(Too few arguments for %s constructor. Received %d but expected %d.)", Variant::get_type_name(builtin_type), p_call->arguments.size(), err.expected), p_call);
  2234. break;
  2235. case Callable::CallError::CALL_ERROR_INSTANCE_IS_NULL:
  2236. case Callable::CallError::CALL_ERROR_METHOD_NOT_CONST:
  2237. break; // Can't happen in a builtin constructor.
  2238. case Callable::CallError::CALL_OK:
  2239. p_call->is_constant = true;
  2240. p_call->reduced_value = value;
  2241. break;
  2242. }
  2243. } else {
  2244. // TODO: Check constructors without constants.
  2245. // If there's one argument, try to use copy constructor (those aren't explicitly defined).
  2246. if (p_call->arguments.size() == 1) {
  2247. GDScriptParser::DataType arg_type = p_call->arguments[0]->get_datatype();
  2248. if (arg_type.is_variant()) {
  2249. mark_node_unsafe(p_call->arguments[0]);
  2250. } else {
  2251. if (arg_type.kind == GDScriptParser::DataType::BUILTIN && arg_type.builtin_type == builtin_type) {
  2252. // Okay.
  2253. p_call->set_datatype(call_type);
  2254. return;
  2255. }
  2256. }
  2257. }
  2258. List<MethodInfo> constructors;
  2259. Variant::get_constructor_list(builtin_type, &constructors);
  2260. bool match = false;
  2261. for (const MethodInfo &info : constructors) {
  2262. if (p_call->arguments.size() < info.arguments.size() - info.default_arguments.size()) {
  2263. continue;
  2264. }
  2265. if (p_call->arguments.size() > info.arguments.size()) {
  2266. continue;
  2267. }
  2268. bool types_match = true;
  2269. for (int i = 0; i < p_call->arguments.size(); i++) {
  2270. GDScriptParser::DataType par_type = type_from_property(info.arguments[i]);
  2271. if (!is_type_compatible(par_type, p_call->arguments[i]->get_datatype(), true)) {
  2272. types_match = false;
  2273. break;
  2274. #ifdef DEBUG_ENABLED
  2275. } else {
  2276. if (par_type.builtin_type == Variant::INT && p_call->arguments[i]->get_datatype().builtin_type == Variant::FLOAT && builtin_type != Variant::INT) {
  2277. parser->push_warning(p_call, GDScriptWarning::NARROWING_CONVERSION, p_call->function_name);
  2278. }
  2279. #endif
  2280. }
  2281. }
  2282. if (types_match) {
  2283. match = true;
  2284. call_type = type_from_property(info.return_val);
  2285. break;
  2286. }
  2287. }
  2288. if (!match) {
  2289. String signature = Variant::get_type_name(builtin_type) + "(";
  2290. for (int i = 0; i < p_call->arguments.size(); i++) {
  2291. if (i > 0) {
  2292. signature += ", ";
  2293. }
  2294. signature += p_call->arguments[i]->get_datatype().to_string();
  2295. }
  2296. signature += ")";
  2297. push_error(vformat(R"(No constructor of "%s" matches the signature "%s".)", Variant::get_type_name(builtin_type), signature), p_call);
  2298. }
  2299. }
  2300. p_call->set_datatype(call_type);
  2301. return;
  2302. } else if (GDScriptUtilityFunctions::function_exists(function_name)) {
  2303. MethodInfo function_info = GDScriptUtilityFunctions::get_function_info(function_name);
  2304. if (all_is_constant && GDScriptUtilityFunctions::is_function_constant(function_name)) {
  2305. // Can call on compilation.
  2306. Vector<const Variant *> args;
  2307. for (int i = 0; i < p_call->arguments.size(); i++) {
  2308. args.push_back(&(p_call->arguments[i]->reduced_value));
  2309. }
  2310. Variant value;
  2311. Callable::CallError err;
  2312. GDScriptUtilityFunctions::get_function(function_name)(&value, (const Variant **)args.ptr(), args.size(), err);
  2313. switch (err.error) {
  2314. case Callable::CallError::CALL_ERROR_INVALID_ARGUMENT: {
  2315. PropertyInfo wrong_arg = function_info.arguments[err.argument];
  2316. push_error(vformat(R"*(Invalid argument for "%s()" function: argument %d should be %s but is %s.)*", function_name, err.argument + 1,
  2317. type_from_property(wrong_arg).to_string(), p_call->arguments[err.argument]->get_datatype().to_string()),
  2318. p_call->arguments[err.argument]);
  2319. } break;
  2320. case Callable::CallError::CALL_ERROR_INVALID_METHOD:
  2321. push_error(vformat(R"(Invalid call for function "%s".)", function_name), p_call);
  2322. break;
  2323. case Callable::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS:
  2324. push_error(vformat(R"*(Too many arguments for "%s()" call. Expected at most %d but received %d.)*", function_name, err.expected, p_call->arguments.size()), p_call);
  2325. break;
  2326. case Callable::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS:
  2327. push_error(vformat(R"*(Too few arguments for "%s()" call. Expected at least %d but received %d.)*", function_name, err.expected, p_call->arguments.size()), p_call);
  2328. break;
  2329. case Callable::CallError::CALL_ERROR_METHOD_NOT_CONST:
  2330. case Callable::CallError::CALL_ERROR_INSTANCE_IS_NULL:
  2331. break; // Can't happen in a builtin constructor.
  2332. case Callable::CallError::CALL_OK:
  2333. p_call->is_constant = true;
  2334. p_call->reduced_value = value;
  2335. break;
  2336. }
  2337. } else {
  2338. validate_call_arg(function_info, p_call);
  2339. }
  2340. p_call->set_datatype(type_from_property(function_info.return_val));
  2341. return;
  2342. } else if (Variant::has_utility_function(function_name)) {
  2343. MethodInfo function_info = info_from_utility_func(function_name);
  2344. if (all_is_constant && Variant::get_utility_function_type(function_name) == Variant::UTILITY_FUNC_TYPE_MATH) {
  2345. // Can call on compilation.
  2346. Vector<const Variant *> args;
  2347. for (int i = 0; i < p_call->arguments.size(); i++) {
  2348. args.push_back(&(p_call->arguments[i]->reduced_value));
  2349. }
  2350. Variant value;
  2351. Callable::CallError err;
  2352. Variant::call_utility_function(function_name, &value, (const Variant **)args.ptr(), args.size(), err);
  2353. switch (err.error) {
  2354. case Callable::CallError::CALL_ERROR_INVALID_ARGUMENT: {
  2355. String expected_type_name;
  2356. if (err.argument < function_info.arguments.size()) {
  2357. expected_type_name = type_from_property(function_info.arguments[err.argument]).to_string();
  2358. } else {
  2359. expected_type_name = Variant::get_type_name((Variant::Type)err.expected);
  2360. }
  2361. push_error(vformat(R"*(Invalid argument for "%s()" function: argument %d should be %s but is %s.)*", function_name, err.argument + 1,
  2362. expected_type_name, p_call->arguments[err.argument]->get_datatype().to_string()),
  2363. p_call->arguments[err.argument]);
  2364. } break;
  2365. case Callable::CallError::CALL_ERROR_INVALID_METHOD:
  2366. push_error(vformat(R"(Invalid call for function "%s".)", function_name), p_call);
  2367. break;
  2368. case Callable::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS:
  2369. push_error(vformat(R"*(Too many arguments for "%s()" call. Expected at most %d but received %d.)*", function_name, err.expected, p_call->arguments.size()), p_call);
  2370. break;
  2371. case Callable::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS:
  2372. push_error(vformat(R"*(Too few arguments for "%s()" call. Expected at least %d but received %d.)*", function_name, err.expected, p_call->arguments.size()), p_call);
  2373. break;
  2374. case Callable::CallError::CALL_ERROR_METHOD_NOT_CONST:
  2375. case Callable::CallError::CALL_ERROR_INSTANCE_IS_NULL:
  2376. break; // Can't happen in a builtin constructor.
  2377. case Callable::CallError::CALL_OK:
  2378. p_call->is_constant = true;
  2379. p_call->reduced_value = value;
  2380. break;
  2381. }
  2382. } else {
  2383. validate_call_arg(function_info, p_call);
  2384. }
  2385. p_call->set_datatype(type_from_property(function_info.return_val));
  2386. return;
  2387. }
  2388. }
  2389. GDScriptParser::DataType base_type;
  2390. call_type.kind = GDScriptParser::DataType::VARIANT;
  2391. bool is_self = false;
  2392. if (p_call->is_super) {
  2393. base_type = parser->current_class->base_type;
  2394. base_type.is_meta_type = false;
  2395. is_self = true;
  2396. if (p_call->callee == nullptr && !lambda_stack.is_empty()) {
  2397. push_error("Cannot use `super()` inside a lambda.", p_call);
  2398. }
  2399. } else if (callee_type == GDScriptParser::Node::IDENTIFIER) {
  2400. base_type = parser->current_class->get_datatype();
  2401. base_type.is_meta_type = false;
  2402. is_self = true;
  2403. } else if (callee_type == GDScriptParser::Node::SUBSCRIPT) {
  2404. GDScriptParser::SubscriptNode *subscript = static_cast<GDScriptParser::SubscriptNode *>(p_call->callee);
  2405. if (subscript->base == nullptr) {
  2406. // Invalid syntax, error already set on parser.
  2407. p_call->set_datatype(call_type);
  2408. mark_node_unsafe(p_call);
  2409. return;
  2410. }
  2411. if (!subscript->is_attribute) {
  2412. // Invalid call. Error already sent in parser.
  2413. // TODO: Could check if Callable here.
  2414. p_call->set_datatype(call_type);
  2415. mark_node_unsafe(p_call);
  2416. return;
  2417. }
  2418. if (subscript->attribute == nullptr) {
  2419. // Invalid call. Error already sent in parser.
  2420. p_call->set_datatype(call_type);
  2421. mark_node_unsafe(p_call);
  2422. return;
  2423. }
  2424. GDScriptParser::IdentifierNode *base_id = nullptr;
  2425. if (subscript->base->type == GDScriptParser::Node::IDENTIFIER) {
  2426. base_id = static_cast<GDScriptParser::IdentifierNode *>(subscript->base);
  2427. }
  2428. if (base_id && GDScriptParser::get_builtin_type(base_id->name) < Variant::VARIANT_MAX) {
  2429. base_type = make_builtin_meta_type(GDScriptParser::get_builtin_type(base_id->name));
  2430. } else {
  2431. reduce_expression(subscript->base);
  2432. base_type = subscript->base->get_datatype();
  2433. }
  2434. } else {
  2435. // Invalid call. Error already sent in parser.
  2436. // TODO: Could check if Callable here too.
  2437. p_call->set_datatype(call_type);
  2438. mark_node_unsafe(p_call);
  2439. return;
  2440. }
  2441. bool is_static = false;
  2442. bool is_vararg = false;
  2443. int default_arg_count = 0;
  2444. GDScriptParser::DataType return_type;
  2445. List<GDScriptParser::DataType> par_types;
  2446. bool is_constructor = (base_type.is_meta_type || (p_call->callee && p_call->callee->type == GDScriptParser::Node::IDENTIFIER)) && p_call->function_name == SNAME("new");
  2447. if (get_function_signature(p_call, is_constructor, base_type, p_call->function_name, return_type, par_types, default_arg_count, is_static, is_vararg)) {
  2448. // If the function require typed arrays we must make literals be typed.
  2449. for (const KeyValue<int, GDScriptParser::ArrayNode *> &E : arrays) {
  2450. int index = E.key;
  2451. if (index < par_types.size() && par_types[index].has_container_element_type()) {
  2452. update_array_literal_element_type(par_types[index], E.value);
  2453. }
  2454. }
  2455. validate_call_arg(par_types, default_arg_count, is_vararg, p_call);
  2456. if (base_type.kind == GDScriptParser::DataType::ENUM && base_type.is_meta_type) {
  2457. // Enum type is treated as a dictionary value for function calls.
  2458. base_type.is_meta_type = false;
  2459. }
  2460. if (is_self && parser->current_function != nullptr && parser->current_function->is_static && !is_static) {
  2461. // Get the parent function above any lambda.
  2462. GDScriptParser::FunctionNode *parent_function = parser->current_function;
  2463. while (parent_function->source_lambda) {
  2464. parent_function = parent_function->source_lambda->parent_function;
  2465. }
  2466. push_error(vformat(R"*(Cannot call non-static function "%s()" from static function "%s()".)*", p_call->function_name, parent_function->identifier->name), p_call);
  2467. } else if (!is_self && base_type.is_meta_type && !is_static) {
  2468. base_type.is_meta_type = false; // For `to_string()`.
  2469. push_error(vformat(R"*(Cannot call non-static function "%s()" on the class "%s" directly. Make an instance instead.)*", p_call->function_name, base_type.to_string()), p_call);
  2470. } else if (is_self && !is_static) {
  2471. mark_lambda_use_self();
  2472. }
  2473. #ifdef DEBUG_ENABLED
  2474. if (p_is_root && return_type.kind != GDScriptParser::DataType::UNRESOLVED && return_type.builtin_type != Variant::NIL) {
  2475. parser->push_warning(p_call, GDScriptWarning::RETURN_VALUE_DISCARDED, p_call->function_name);
  2476. }
  2477. if (is_static && !base_type.is_meta_type && !(is_self && parser->current_function != nullptr && parser->current_function->is_static)) {
  2478. String caller_type = String(base_type.native_type);
  2479. if (caller_type.is_empty()) {
  2480. caller_type = base_type.to_string();
  2481. }
  2482. parser->push_warning(p_call, GDScriptWarning::STATIC_CALLED_ON_INSTANCE, p_call->function_name, caller_type);
  2483. }
  2484. #endif // DEBUG_ENABLED
  2485. call_type = return_type;
  2486. } else {
  2487. bool found = false;
  2488. // Check if the name exists as something else.
  2489. if (!p_call->is_super && callee_type != GDScriptParser::Node::NONE) {
  2490. GDScriptParser::IdentifierNode *callee_id;
  2491. if (callee_type == GDScriptParser::Node::IDENTIFIER) {
  2492. callee_id = static_cast<GDScriptParser::IdentifierNode *>(p_call->callee);
  2493. } else {
  2494. // Can only be attribute.
  2495. callee_id = static_cast<GDScriptParser::SubscriptNode *>(p_call->callee)->attribute;
  2496. }
  2497. if (callee_id) {
  2498. reduce_identifier_from_base(callee_id, &base_type);
  2499. GDScriptParser::DataType callee_datatype = callee_id->get_datatype();
  2500. if (callee_datatype.is_set() && !callee_datatype.is_variant()) {
  2501. found = true;
  2502. if (callee_datatype.builtin_type == Variant::CALLABLE) {
  2503. push_error(vformat(R"*(Name "%s" is a Callable. You can call it with "%s.call()" instead.)*", p_call->function_name, p_call->function_name), p_call->callee);
  2504. } else {
  2505. push_error(vformat(R"*(Name "%s" called as a function but is a "%s".)*", p_call->function_name, callee_datatype.to_string()), p_call->callee);
  2506. }
  2507. #ifdef DEBUG_ENABLED
  2508. } else if (!is_self && !(base_type.is_hard_type() && base_type.kind == GDScriptParser::DataType::BUILTIN)) {
  2509. parser->push_warning(p_call, GDScriptWarning::UNSAFE_METHOD_ACCESS, p_call->function_name, base_type.to_string());
  2510. mark_node_unsafe(p_call);
  2511. #endif
  2512. }
  2513. }
  2514. }
  2515. if (!found && (is_self || (base_type.is_hard_type() && base_type.kind == GDScriptParser::DataType::BUILTIN))) {
  2516. String base_name = is_self && !p_call->is_super ? "self" : base_type.to_string();
  2517. push_error(vformat(R"*(Function "%s()" not found in base %s.)*", p_call->function_name, base_name), p_call->is_super ? p_call : p_call->callee);
  2518. } else if (!found && (!p_call->is_super && base_type.is_hard_type() && base_type.kind == GDScriptParser::DataType::NATIVE && base_type.is_meta_type)) {
  2519. push_error(vformat(R"*(Static function "%s()" not found in base "%s".)*", p_call->function_name, base_type.native_type.operator String()), p_call);
  2520. }
  2521. }
  2522. if (call_type.is_coroutine && !p_is_await && !p_is_root) {
  2523. push_error(vformat(R"*(Function "%s()" is a coroutine, so it must be called with "await".)*", p_call->function_name), p_call);
  2524. }
  2525. p_call->set_datatype(call_type);
  2526. }
  2527. void GDScriptAnalyzer::reduce_cast(GDScriptParser::CastNode *p_cast) {
  2528. reduce_expression(p_cast->operand);
  2529. GDScriptParser::DataType cast_type = resolve_datatype(p_cast->cast_type);
  2530. if (!cast_type.is_set()) {
  2531. mark_node_unsafe(p_cast);
  2532. return;
  2533. }
  2534. cast_type = type_from_metatype(cast_type); // The casted value won't be a type name.
  2535. p_cast->set_datatype(cast_type);
  2536. if (!cast_type.is_variant()) {
  2537. GDScriptParser::DataType op_type = p_cast->operand->get_datatype();
  2538. if (!op_type.is_variant()) {
  2539. bool valid = false;
  2540. if (op_type.kind == GDScriptParser::DataType::ENUM && cast_type.kind == GDScriptParser::DataType::ENUM) {
  2541. // Enum types are compatible between each other, so it's a safe cast.
  2542. valid = true;
  2543. } else if (op_type.kind == GDScriptParser::DataType::BUILTIN && op_type.builtin_type == Variant::INT && cast_type.kind == GDScriptParser::DataType::ENUM) {
  2544. // Convertint int to enum is always valid.
  2545. valid = true;
  2546. } else if (op_type.kind == GDScriptParser::DataType::BUILTIN && cast_type.kind == GDScriptParser::DataType::BUILTIN) {
  2547. valid = Variant::can_convert(op_type.builtin_type, cast_type.builtin_type);
  2548. } else if (op_type.kind != GDScriptParser::DataType::BUILTIN && cast_type.kind != GDScriptParser::DataType::BUILTIN) {
  2549. valid = is_type_compatible(cast_type, op_type) || is_type_compatible(op_type, cast_type);
  2550. }
  2551. if (!valid) {
  2552. push_error(vformat(R"(Invalid cast. Cannot convert from "%s" to "%s".)", op_type.to_string(), cast_type.to_string()), p_cast->cast_type);
  2553. }
  2554. }
  2555. } else {
  2556. mark_node_unsafe(p_cast);
  2557. }
  2558. #ifdef DEBUG_ENABLED
  2559. if (p_cast->operand->get_datatype().is_variant()) {
  2560. parser->push_warning(p_cast, GDScriptWarning::UNSAFE_CAST, cast_type.to_string());
  2561. mark_node_unsafe(p_cast);
  2562. }
  2563. #endif
  2564. // TODO: Perform cast on constants.
  2565. }
  2566. void GDScriptAnalyzer::reduce_dictionary(GDScriptParser::DictionaryNode *p_dictionary) {
  2567. HashMap<Variant, GDScriptParser::ExpressionNode *, VariantHasher, StringLikeVariantComparator> elements;
  2568. for (int i = 0; i < p_dictionary->elements.size(); i++) {
  2569. const GDScriptParser::DictionaryNode::Pair &element = p_dictionary->elements[i];
  2570. if (p_dictionary->style == GDScriptParser::DictionaryNode::PYTHON_DICT) {
  2571. reduce_expression(element.key);
  2572. }
  2573. reduce_expression(element.value);
  2574. if (element.key->is_constant) {
  2575. if (elements.has(element.key->reduced_value)) {
  2576. push_error(vformat(R"(Key "%s" was already used in this dictionary (at line %d).)", element.key->reduced_value, elements[element.key->reduced_value]->start_line), element.key);
  2577. } else {
  2578. elements[element.key->reduced_value] = element.value;
  2579. }
  2580. }
  2581. }
  2582. // It's dictionary in any case.
  2583. GDScriptParser::DataType dict_type;
  2584. dict_type.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
  2585. dict_type.kind = GDScriptParser::DataType::BUILTIN;
  2586. dict_type.builtin_type = Variant::DICTIONARY;
  2587. dict_type.is_constant = true;
  2588. p_dictionary->set_datatype(dict_type);
  2589. }
  2590. void GDScriptAnalyzer::reduce_get_node(GDScriptParser::GetNodeNode *p_get_node) {
  2591. GDScriptParser::DataType result;
  2592. result.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
  2593. result.kind = GDScriptParser::DataType::NATIVE;
  2594. result.native_type = SNAME("Node");
  2595. result.builtin_type = Variant::OBJECT;
  2596. if (!ClassDB::is_parent_class(parser->current_class->base_type.native_type, result.native_type)) {
  2597. push_error(R"*(Cannot use shorthand "get_node()" notation ("$") on a class that isn't a node.)*", p_get_node);
  2598. }
  2599. mark_lambda_use_self();
  2600. p_get_node->set_datatype(result);
  2601. }
  2602. GDScriptParser::DataType GDScriptAnalyzer::make_global_class_meta_type(const StringName &p_class_name, const GDScriptParser::Node *p_source) {
  2603. GDScriptParser::DataType type;
  2604. String path = ScriptServer::get_global_class_path(p_class_name);
  2605. String ext = path.get_extension();
  2606. if (ext == GDScriptLanguage::get_singleton()->get_extension()) {
  2607. Ref<GDScriptParserRef> ref = get_parser_for(path);
  2608. if (ref.is_null()) {
  2609. push_error(vformat(R"(Could not find script for class "%s".)", p_class_name), p_source);
  2610. type.type_source = GDScriptParser::DataType::UNDETECTED;
  2611. type.kind = GDScriptParser::DataType::VARIANT;
  2612. return type;
  2613. }
  2614. Error err = ref->raise_status(GDScriptParserRef::INHERITANCE_SOLVED);
  2615. if (err) {
  2616. push_error(vformat(R"(Could not resolve class "%s", because of a parser error.)", p_class_name), p_source);
  2617. type.type_source = GDScriptParser::DataType::UNDETECTED;
  2618. type.kind = GDScriptParser::DataType::VARIANT;
  2619. return type;
  2620. }
  2621. return ref->get_parser()->head->get_datatype();
  2622. } else {
  2623. type.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
  2624. type.kind = GDScriptParser::DataType::SCRIPT;
  2625. type.builtin_type = Variant::OBJECT;
  2626. type.script_type = ResourceLoader::load(path, "Script");
  2627. type.native_type = type.script_type->get_instance_base_type();
  2628. type.script_path = path;
  2629. type.is_constant = true;
  2630. type.is_meta_type = true;
  2631. return type;
  2632. }
  2633. }
  2634. void GDScriptAnalyzer::reduce_identifier_from_base(GDScriptParser::IdentifierNode *p_identifier, GDScriptParser::DataType *p_base) {
  2635. if (!p_identifier->get_datatype().has_no_type()) {
  2636. return;
  2637. }
  2638. GDScriptParser::DataType base;
  2639. if (p_base == nullptr) {
  2640. base = type_from_metatype(parser->current_class->get_datatype());
  2641. } else {
  2642. base = *p_base;
  2643. }
  2644. const StringName &name = p_identifier->name;
  2645. if (base.kind == GDScriptParser::DataType::ENUM) {
  2646. if (base.is_meta_type) {
  2647. if (base.enum_values.has(name)) {
  2648. p_identifier->is_constant = true;
  2649. p_identifier->reduced_value = base.enum_values[name];
  2650. GDScriptParser::DataType result;
  2651. result.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
  2652. result.kind = GDScriptParser::DataType::ENUM;
  2653. result.is_constant = true;
  2654. result.builtin_type = Variant::INT;
  2655. result.native_type = base.native_type;
  2656. result.enum_type = base.enum_type;
  2657. result.enum_values = base.enum_values;
  2658. p_identifier->set_datatype(result);
  2659. return;
  2660. } else {
  2661. // Consider as a Dictionary, so it can be anything.
  2662. // This will be evaluated in the next if block.
  2663. base.kind = GDScriptParser::DataType::BUILTIN;
  2664. base.builtin_type = Variant::DICTIONARY;
  2665. base.is_meta_type = false;
  2666. }
  2667. } else {
  2668. push_error(R"(Cannot get property from enum value.)", p_identifier);
  2669. return;
  2670. }
  2671. }
  2672. if (base.kind == GDScriptParser::DataType::BUILTIN) {
  2673. if (base.is_meta_type) {
  2674. bool valid = true;
  2675. Variant result = Variant::get_constant_value(base.builtin_type, name, &valid);
  2676. if (valid) {
  2677. p_identifier->is_constant = true;
  2678. p_identifier->reduced_value = result;
  2679. p_identifier->set_datatype(type_from_variant(result, p_identifier));
  2680. } else if (base.is_hard_type()) {
  2681. push_error(vformat(R"(Cannot find constant "%s" on type "%s".)", name, base.to_string()), p_identifier);
  2682. }
  2683. } else {
  2684. switch (base.builtin_type) {
  2685. case Variant::NIL: {
  2686. if (base.is_hard_type()) {
  2687. push_error(vformat(R"(Invalid get index "%s" on base Nil)", name), p_identifier);
  2688. }
  2689. return;
  2690. }
  2691. case Variant::DICTIONARY: {
  2692. GDScriptParser::DataType dummy;
  2693. dummy.kind = GDScriptParser::DataType::VARIANT;
  2694. p_identifier->set_datatype(dummy);
  2695. return;
  2696. }
  2697. default: {
  2698. Callable::CallError temp;
  2699. Variant dummy;
  2700. Variant::construct(base.builtin_type, dummy, nullptr, 0, temp);
  2701. List<PropertyInfo> properties;
  2702. dummy.get_property_list(&properties);
  2703. for (const PropertyInfo &prop : properties) {
  2704. if (prop.name == name) {
  2705. p_identifier->set_datatype(type_from_property(prop));
  2706. return;
  2707. }
  2708. }
  2709. if (base.is_hard_type()) {
  2710. push_error(vformat(R"(Cannot find property "%s" on base "%s".)", name, base.to_string()), p_identifier);
  2711. }
  2712. }
  2713. }
  2714. }
  2715. return;
  2716. }
  2717. GDScriptParser::ClassNode *base_class = base.class_type;
  2718. // TODO: Switch current class/function/suite here to avoid misrepresenting identifiers (in recursive reduce calls).
  2719. while (base_class != nullptr) {
  2720. if (base_class->identifier && base_class->identifier->name == name) {
  2721. p_identifier->set_datatype(base_class->get_datatype());
  2722. return;
  2723. }
  2724. if (base_class->has_member(name)) {
  2725. resolve_class_member(base_class, name, p_identifier);
  2726. GDScriptParser::ClassNode::Member member = base_class->get_member(name);
  2727. p_identifier->set_datatype(member.get_datatype());
  2728. switch (member.type) {
  2729. case GDScriptParser::ClassNode::Member::CONSTANT:
  2730. p_identifier->is_constant = true;
  2731. p_identifier->reduced_value = member.constant->initializer->reduced_value;
  2732. p_identifier->source = GDScriptParser::IdentifierNode::MEMBER_CONSTANT;
  2733. p_identifier->constant_source = member.constant;
  2734. break;
  2735. case GDScriptParser::ClassNode::Member::ENUM_VALUE:
  2736. p_identifier->is_constant = true;
  2737. p_identifier->reduced_value = member.enum_value.value;
  2738. p_identifier->source = GDScriptParser::IdentifierNode::MEMBER_CONSTANT;
  2739. break;
  2740. case GDScriptParser::ClassNode::Member::VARIABLE:
  2741. p_identifier->source = GDScriptParser::IdentifierNode::MEMBER_VARIABLE;
  2742. p_identifier->variable_source = member.variable;
  2743. member.variable->usages += 1;
  2744. break;
  2745. case GDScriptParser::ClassNode::Member::SIGNAL:
  2746. p_identifier->source = GDScriptParser::IdentifierNode::MEMBER_SIGNAL;
  2747. break;
  2748. case GDScriptParser::ClassNode::Member::FUNCTION:
  2749. p_identifier->set_datatype(make_callable_type(member.function->info));
  2750. break;
  2751. default:
  2752. break; // Type already set.
  2753. }
  2754. return;
  2755. }
  2756. // Check outer constants.
  2757. // TODO: Allow outer static functions.
  2758. if (base_class->outer != nullptr) {
  2759. List<GDScriptParser::ClassNode *> script_classes;
  2760. get_class_node_current_scope_classes(parser->current_class, &script_classes);
  2761. for (GDScriptParser::ClassNode *script_class : script_classes) {
  2762. if (script_class->has_member(name)) {
  2763. resolve_class_member(script_class, name, p_identifier);
  2764. GDScriptParser::ClassNode::Member member = script_class->get_member(name);
  2765. switch (member.type) {
  2766. case GDScriptParser::ClassNode::Member::CONSTANT:
  2767. // TODO: Make sure loops won't cause problem. And make special error message for those.
  2768. p_identifier->set_datatype(member.get_datatype());
  2769. p_identifier->is_constant = true;
  2770. p_identifier->reduced_value = member.constant->initializer->reduced_value;
  2771. return;
  2772. case GDScriptParser::ClassNode::Member::ENUM_VALUE:
  2773. p_identifier->set_datatype(member.get_datatype());
  2774. p_identifier->is_constant = true;
  2775. p_identifier->reduced_value = member.enum_value.value;
  2776. return;
  2777. case GDScriptParser::ClassNode::Member::ENUM:
  2778. p_identifier->set_datatype(member.get_datatype());
  2779. p_identifier->is_constant = false;
  2780. return;
  2781. case GDScriptParser::ClassNode::Member::CLASS:
  2782. p_identifier->set_datatype(member.get_datatype());
  2783. return;
  2784. default:
  2785. break;
  2786. }
  2787. }
  2788. }
  2789. }
  2790. base_class = base_class->base_type.class_type;
  2791. }
  2792. // Check native members. No need for native class recursion because Node exposes all Object's properties.
  2793. const StringName &native = base.native_type;
  2794. if (class_exists(native)) {
  2795. MethodInfo method_info;
  2796. if (ClassDB::has_property(native, name)) {
  2797. StringName getter_name = ClassDB::get_property_getter(native, name);
  2798. MethodBind *getter = ClassDB::get_method(native, getter_name);
  2799. if (getter != nullptr) {
  2800. p_identifier->set_datatype(type_from_property(getter->get_return_info()));
  2801. p_identifier->source = GDScriptParser::IdentifierNode::INHERITED_VARIABLE;
  2802. }
  2803. return;
  2804. }
  2805. if (ClassDB::get_method_info(native, name, &method_info)) {
  2806. // Method is callable.
  2807. p_identifier->set_datatype(make_callable_type(method_info));
  2808. p_identifier->source = GDScriptParser::IdentifierNode::INHERITED_VARIABLE;
  2809. return;
  2810. }
  2811. if (ClassDB::get_signal(native, name, &method_info)) {
  2812. // Signal is a type too.
  2813. p_identifier->set_datatype(make_signal_type(method_info));
  2814. p_identifier->source = GDScriptParser::IdentifierNode::INHERITED_VARIABLE;
  2815. return;
  2816. }
  2817. if (ClassDB::has_enum(native, name)) {
  2818. p_identifier->set_datatype(make_native_enum_type(native, name));
  2819. p_identifier->source = GDScriptParser::IdentifierNode::MEMBER_CONSTANT;
  2820. return;
  2821. }
  2822. bool valid = false;
  2823. int64_t int_constant = ClassDB::get_integer_constant(native, name, &valid);
  2824. if (valid) {
  2825. p_identifier->is_constant = true;
  2826. p_identifier->reduced_value = int_constant;
  2827. p_identifier->set_datatype(type_from_variant(int_constant, p_identifier));
  2828. p_identifier->source = GDScriptParser::IdentifierNode::MEMBER_CONSTANT;
  2829. return;
  2830. }
  2831. }
  2832. }
  2833. void GDScriptAnalyzer::reduce_identifier(GDScriptParser::IdentifierNode *p_identifier, bool can_be_builtin) {
  2834. // TODO: This is opportunity to further infer types.
  2835. // Check if we are inside and enum. This allows enum values to access other elements of the same enum.
  2836. if (current_enum) {
  2837. for (int i = 0; i < current_enum->values.size(); i++) {
  2838. const GDScriptParser::EnumNode::Value &element = current_enum->values[i];
  2839. if (element.identifier->name == p_identifier->name) {
  2840. GDScriptParser::DataType type;
  2841. type.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
  2842. type.kind = element.parent_enum->identifier ? GDScriptParser::DataType::ENUM : GDScriptParser::DataType::BUILTIN;
  2843. type.builtin_type = Variant::INT;
  2844. type.is_constant = true;
  2845. if (element.parent_enum->identifier) {
  2846. type.enum_type = element.parent_enum->identifier->name;
  2847. }
  2848. p_identifier->set_datatype(type);
  2849. if (element.resolved) {
  2850. p_identifier->is_constant = true;
  2851. p_identifier->reduced_value = element.value;
  2852. } else {
  2853. push_error(R"(Cannot use another enum element before it was declared.)", p_identifier);
  2854. }
  2855. return; // Found anyway.
  2856. }
  2857. }
  2858. }
  2859. bool found_source = false;
  2860. // Check if identifier is local.
  2861. // If that's the case, the declaration already was solved before.
  2862. switch (p_identifier->source) {
  2863. case GDScriptParser::IdentifierNode::FUNCTION_PARAMETER:
  2864. p_identifier->set_datatype(p_identifier->parameter_source->get_datatype());
  2865. found_source = true;
  2866. break;
  2867. case GDScriptParser::IdentifierNode::LOCAL_CONSTANT:
  2868. case GDScriptParser::IdentifierNode::MEMBER_CONSTANT:
  2869. p_identifier->set_datatype(p_identifier->constant_source->get_datatype());
  2870. p_identifier->is_constant = true;
  2871. // TODO: Constant should have a value on the node itself.
  2872. p_identifier->reduced_value = p_identifier->constant_source->initializer->reduced_value;
  2873. found_source = true;
  2874. break;
  2875. case GDScriptParser::IdentifierNode::MEMBER_SIGNAL:
  2876. case GDScriptParser::IdentifierNode::INHERITED_VARIABLE:
  2877. mark_lambda_use_self();
  2878. break;
  2879. case GDScriptParser::IdentifierNode::MEMBER_VARIABLE:
  2880. mark_lambda_use_self();
  2881. p_identifier->variable_source->usages++;
  2882. [[fallthrough]];
  2883. case GDScriptParser::IdentifierNode::LOCAL_VARIABLE:
  2884. p_identifier->set_datatype(p_identifier->variable_source->get_datatype());
  2885. found_source = true;
  2886. break;
  2887. case GDScriptParser::IdentifierNode::LOCAL_ITERATOR:
  2888. p_identifier->set_datatype(p_identifier->bind_source->get_datatype());
  2889. found_source = true;
  2890. break;
  2891. case GDScriptParser::IdentifierNode::LOCAL_BIND: {
  2892. GDScriptParser::DataType result = p_identifier->bind_source->get_datatype();
  2893. result.is_constant = true;
  2894. p_identifier->set_datatype(result);
  2895. found_source = true;
  2896. } break;
  2897. case GDScriptParser::IdentifierNode::UNDEFINED_SOURCE:
  2898. break;
  2899. }
  2900. // Not a local, so check members.
  2901. if (!found_source) {
  2902. reduce_identifier_from_base(p_identifier);
  2903. if (p_identifier->source != GDScriptParser::IdentifierNode::UNDEFINED_SOURCE || p_identifier->get_datatype().is_set()) {
  2904. // Found.
  2905. found_source = true;
  2906. }
  2907. }
  2908. if (found_source) {
  2909. if ((p_identifier->source == GDScriptParser::IdentifierNode::MEMBER_VARIABLE || p_identifier->source == GDScriptParser::IdentifierNode::INHERITED_VARIABLE) && parser->current_function && parser->current_function->is_static) {
  2910. // Get the parent function above any lambda.
  2911. GDScriptParser::FunctionNode *parent_function = parser->current_function;
  2912. while (parent_function->source_lambda) {
  2913. parent_function = parent_function->source_lambda->parent_function;
  2914. }
  2915. push_error(vformat(R"*(Cannot access instance variable "%s" from the static function "%s()".)*", p_identifier->name, parent_function->identifier->name), p_identifier);
  2916. }
  2917. if (!lambda_stack.is_empty()) {
  2918. // If the identifier is a member variable (including the native class properties), we consider the lambda to be using `self`, so we keep a reference to the current instance.
  2919. if (p_identifier->source == GDScriptParser::IdentifierNode::MEMBER_VARIABLE || p_identifier->source == GDScriptParser::IdentifierNode::INHERITED_VARIABLE) {
  2920. mark_lambda_use_self();
  2921. return; // No need to capture.
  2922. }
  2923. // If the identifier is local, check if it's any kind of capture by comparing their source function.
  2924. // Only capture locals and enum values. Constants are still accessible from the lambda using the script reference. If not, this method is done.
  2925. if (p_identifier->source == GDScriptParser::IdentifierNode::UNDEFINED_SOURCE || p_identifier->source == GDScriptParser::IdentifierNode::MEMBER_CONSTANT) {
  2926. return;
  2927. }
  2928. GDScriptParser::FunctionNode *function_test = lambda_stack.back()->get()->function;
  2929. // Make sure we aren't capturing variable in the same lambda.
  2930. // This also add captures for nested lambdas.
  2931. while (function_test != nullptr && function_test != p_identifier->source_function && function_test->source_lambda != nullptr && !function_test->source_lambda->captures_indices.has(p_identifier->name)) {
  2932. function_test->source_lambda->captures_indices[p_identifier->name] = function_test->source_lambda->captures.size();
  2933. function_test->source_lambda->captures.push_back(p_identifier);
  2934. function_test = function_test->source_lambda->parent_function;
  2935. }
  2936. }
  2937. return;
  2938. }
  2939. StringName name = p_identifier->name;
  2940. p_identifier->source = GDScriptParser::IdentifierNode::UNDEFINED_SOURCE;
  2941. // Check globals. We make an exception for Variant::OBJECT because it's the base class for
  2942. // non-builtin types so we allow doing e.g. Object.new()
  2943. Variant::Type builtin_type = GDScriptParser::get_builtin_type(name);
  2944. if (builtin_type != Variant::OBJECT && builtin_type < Variant::VARIANT_MAX) {
  2945. if (can_be_builtin) {
  2946. p_identifier->set_datatype(make_builtin_meta_type(builtin_type));
  2947. return;
  2948. } else {
  2949. push_error(R"(Builtin type cannot be used as a name on its own.)", p_identifier);
  2950. }
  2951. }
  2952. if (class_exists(name)) {
  2953. p_identifier->set_datatype(make_native_meta_type(name));
  2954. return;
  2955. }
  2956. if (ScriptServer::is_global_class(name)) {
  2957. p_identifier->set_datatype(make_global_class_meta_type(name, p_identifier));
  2958. return;
  2959. }
  2960. // Try singletons.
  2961. // Do this before globals because this might be a singleton loading another one before it's compiled.
  2962. if (ProjectSettings::get_singleton()->has_autoload(name)) {
  2963. const ProjectSettings::AutoloadInfo &autoload = ProjectSettings::get_singleton()->get_autoload(name);
  2964. if (autoload.is_singleton) {
  2965. // Singleton exists, so it's at least a Node.
  2966. GDScriptParser::DataType result;
  2967. result.kind = GDScriptParser::DataType::NATIVE;
  2968. result.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
  2969. if (ResourceLoader::get_resource_type(autoload.path) == "GDScript") {
  2970. Ref<GDScriptParserRef> singl_parser = get_parser_for(autoload.path);
  2971. if (singl_parser.is_valid()) {
  2972. Error err = singl_parser->raise_status(GDScriptParserRef::INHERITANCE_SOLVED);
  2973. if (err == OK) {
  2974. result = type_from_metatype(singl_parser->get_parser()->head->get_datatype());
  2975. }
  2976. }
  2977. } else if (ResourceLoader::get_resource_type(autoload.path) == "PackedScene") {
  2978. if (GDScriptLanguage::get_singleton()->get_named_globals_map().has(name)) {
  2979. Variant constant = GDScriptLanguage::get_singleton()->get_named_globals_map()[name];
  2980. Node *node = Object::cast_to<Node>(constant);
  2981. if (node != nullptr) {
  2982. Ref<GDScript> scr = node->get_script();
  2983. if (scr.is_valid()) {
  2984. Ref<GDScriptParserRef> singl_parser = get_parser_for(scr->get_script_path());
  2985. if (singl_parser.is_valid()) {
  2986. Error err = singl_parser->raise_status(GDScriptParserRef::INHERITANCE_SOLVED);
  2987. if (err == OK) {
  2988. result = type_from_metatype(singl_parser->get_parser()->head->get_datatype());
  2989. }
  2990. }
  2991. }
  2992. }
  2993. }
  2994. }
  2995. result.is_constant = true;
  2996. p_identifier->set_datatype(result);
  2997. return;
  2998. }
  2999. }
  3000. if (GDScriptLanguage::get_singleton()->get_global_map().has(name)) {
  3001. int idx = GDScriptLanguage::get_singleton()->get_global_map()[name];
  3002. Variant constant = GDScriptLanguage::get_singleton()->get_global_array()[idx];
  3003. p_identifier->set_datatype(type_from_variant(constant, p_identifier));
  3004. p_identifier->is_constant = true;
  3005. p_identifier->reduced_value = constant;
  3006. return;
  3007. }
  3008. if (GDScriptLanguage::get_singleton()->get_named_globals_map().has(name)) {
  3009. Variant constant = GDScriptLanguage::get_singleton()->get_named_globals_map()[name];
  3010. p_identifier->set_datatype(type_from_variant(constant, p_identifier));
  3011. p_identifier->is_constant = true;
  3012. p_identifier->reduced_value = constant;
  3013. return;
  3014. }
  3015. // Not found.
  3016. // Check if it's a builtin function.
  3017. if (GDScriptUtilityFunctions::function_exists(name)) {
  3018. push_error(vformat(R"(Built-in function "%s" cannot be used as an identifier.)", name), p_identifier);
  3019. } else {
  3020. push_error(vformat(R"(Identifier "%s" not declared in the current scope.)", name), p_identifier);
  3021. }
  3022. GDScriptParser::DataType dummy;
  3023. dummy.kind = GDScriptParser::DataType::VARIANT;
  3024. p_identifier->set_datatype(dummy); // Just so type is set to something.
  3025. }
  3026. void GDScriptAnalyzer::reduce_lambda(GDScriptParser::LambdaNode *p_lambda) {
  3027. // Lambda is always a Callable.
  3028. GDScriptParser::DataType lambda_type;
  3029. lambda_type.type_source = GDScriptParser::DataType::ANNOTATED_INFERRED;
  3030. lambda_type.kind = GDScriptParser::DataType::BUILTIN;
  3031. lambda_type.builtin_type = Variant::CALLABLE;
  3032. p_lambda->set_datatype(lambda_type);
  3033. if (p_lambda->function == nullptr) {
  3034. return;
  3035. }
  3036. GDScriptParser::FunctionNode *previous_function = parser->current_function;
  3037. parser->current_function = p_lambda->function;
  3038. lambda_stack.push_back(p_lambda);
  3039. for (int i = 0; i < p_lambda->function->parameters.size(); i++) {
  3040. resolve_parameter(p_lambda->function->parameters[i]);
  3041. }
  3042. resolve_suite(p_lambda->function->body);
  3043. int captures_amount = p_lambda->captures.size();
  3044. if (captures_amount > 0) {
  3045. // Create space for lambda parameters.
  3046. // At the beginning to not mess with optional parameters.
  3047. int param_count = p_lambda->function->parameters.size();
  3048. p_lambda->function->parameters.resize(param_count + captures_amount);
  3049. for (int i = param_count - 1; i >= 0; i--) {
  3050. p_lambda->function->parameters.write[i + captures_amount] = p_lambda->function->parameters[i];
  3051. p_lambda->function->parameters_indices[p_lambda->function->parameters[i]->identifier->name] = i + captures_amount;
  3052. }
  3053. // Add captures as extra parameters at the beginning.
  3054. for (int i = 0; i < p_lambda->captures.size(); i++) {
  3055. GDScriptParser::IdentifierNode *capture = p_lambda->captures[i];
  3056. GDScriptParser::ParameterNode *capture_param = parser->alloc_node<GDScriptParser::ParameterNode>();
  3057. capture_param->identifier = capture;
  3058. capture_param->usages = capture->usages;
  3059. capture_param->set_datatype(capture->get_datatype());
  3060. p_lambda->function->parameters.write[i] = capture_param;
  3061. p_lambda->function->parameters_indices[capture->name] = i;
  3062. }
  3063. }
  3064. lambda_stack.pop_back();
  3065. parser->current_function = previous_function;
  3066. }
  3067. void GDScriptAnalyzer::reduce_literal(GDScriptParser::LiteralNode *p_literal) {
  3068. p_literal->reduced_value = p_literal->value;
  3069. p_literal->is_constant = true;
  3070. p_literal->set_datatype(type_from_variant(p_literal->reduced_value, p_literal));
  3071. }
  3072. void GDScriptAnalyzer::reduce_preload(GDScriptParser::PreloadNode *p_preload) {
  3073. if (!p_preload->path) {
  3074. return;
  3075. }
  3076. reduce_expression(p_preload->path);
  3077. if (!p_preload->path->is_constant) {
  3078. push_error("Preloaded path must be a constant string.", p_preload->path);
  3079. return;
  3080. }
  3081. if (p_preload->path->reduced_value.get_type() != Variant::STRING) {
  3082. push_error("Preloaded path must be a constant string.", p_preload->path);
  3083. } else {
  3084. p_preload->resolved_path = p_preload->path->reduced_value;
  3085. // TODO: Save this as script dependency.
  3086. if (p_preload->resolved_path.is_relative_path()) {
  3087. p_preload->resolved_path = parser->script_path.get_base_dir().path_join(p_preload->resolved_path);
  3088. }
  3089. p_preload->resolved_path = p_preload->resolved_path.simplify_path();
  3090. if (!ResourceLoader::exists(p_preload->resolved_path)) {
  3091. Ref<FileAccess> file_check = FileAccess::create(FileAccess::ACCESS_RESOURCES);
  3092. if (file_check->file_exists(p_preload->resolved_path)) {
  3093. push_error(vformat(R"(Preload file "%s" has no resource loaders (unrecognized file extension).)", p_preload->resolved_path), p_preload->path);
  3094. } else {
  3095. push_error(vformat(R"(Preload file "%s" does not exist.)", p_preload->resolved_path), p_preload->path);
  3096. }
  3097. } else {
  3098. // TODO: Don't load if validating: use completion cache.
  3099. // Must load GDScript and PackedScenes separately to permit cyclic references
  3100. // as ResourceLoader::load() detect and reject those.
  3101. if (ResourceLoader::get_resource_type(p_preload->resolved_path) == "GDScript") {
  3102. Error err = OK;
  3103. Ref<GDScript> res = GDScriptCache::get_shallow_script(p_preload->resolved_path, err, parser->script_path);
  3104. p_preload->resource = res;
  3105. if (err != OK) {
  3106. push_error(vformat(R"(Could not preload resource script "%s".)", p_preload->resolved_path), p_preload->path);
  3107. }
  3108. } else if (ResourceLoader::get_resource_type(p_preload->resolved_path) == "PackedScene") {
  3109. Error err = OK;
  3110. Ref<PackedScene> res = GDScriptCache::get_packed_scene(p_preload->resolved_path, err, parser->script_path);
  3111. p_preload->resource = res;
  3112. if (err != OK) {
  3113. push_error(vformat(R"(Could not preload resource scene "%s".)", p_preload->resolved_path), p_preload->path);
  3114. }
  3115. } else {
  3116. p_preload->resource = ResourceLoader::load(p_preload->resolved_path);
  3117. if (p_preload->resource.is_null()) {
  3118. push_error(vformat(R"(Could not preload resource file "%s".)", p_preload->resolved_path), p_preload->path);
  3119. }
  3120. }
  3121. }
  3122. }
  3123. p_preload->is_constant = true;
  3124. p_preload->reduced_value = p_preload->resource;
  3125. p_preload->set_datatype(type_from_variant(p_preload->reduced_value, p_preload));
  3126. }
  3127. void GDScriptAnalyzer::reduce_self(GDScriptParser::SelfNode *p_self) {
  3128. p_self->is_constant = false;
  3129. p_self->set_datatype(type_from_metatype(parser->current_class->get_datatype()));
  3130. mark_lambda_use_self();
  3131. }
  3132. void GDScriptAnalyzer::reduce_subscript(GDScriptParser::SubscriptNode *p_subscript) {
  3133. if (p_subscript->base == nullptr) {
  3134. return;
  3135. }
  3136. if (p_subscript->base->type == GDScriptParser::Node::IDENTIFIER) {
  3137. reduce_identifier(static_cast<GDScriptParser::IdentifierNode *>(p_subscript->base), true);
  3138. } else {
  3139. reduce_expression(p_subscript->base);
  3140. if (p_subscript->base->type == GDScriptParser::Node::ARRAY) {
  3141. const_fold_array(static_cast<GDScriptParser::ArrayNode *>(p_subscript->base));
  3142. } else if (p_subscript->base->type == GDScriptParser::Node::DICTIONARY) {
  3143. const_fold_dictionary(static_cast<GDScriptParser::DictionaryNode *>(p_subscript->base));
  3144. }
  3145. }
  3146. GDScriptParser::DataType result_type;
  3147. if (p_subscript->is_attribute) {
  3148. if (p_subscript->attribute == nullptr) {
  3149. return;
  3150. }
  3151. GDScriptParser::DataType base_type = p_subscript->base->get_datatype();
  3152. bool valid = false;
  3153. // If the base is a metatype, use the analyzer instead.
  3154. if (p_subscript->base->is_constant && !base_type.is_meta_type) {
  3155. // Just try to get it.
  3156. Variant value = p_subscript->base->reduced_value.get_named(p_subscript->attribute->name, valid);
  3157. if (valid) {
  3158. p_subscript->is_constant = true;
  3159. p_subscript->reduced_value = value;
  3160. result_type = type_from_variant(value, p_subscript);
  3161. }
  3162. } else if (base_type.is_variant() || !base_type.is_hard_type()) {
  3163. valid = true;
  3164. result_type.kind = GDScriptParser::DataType::VARIANT;
  3165. mark_node_unsafe(p_subscript);
  3166. } else {
  3167. reduce_identifier_from_base(p_subscript->attribute, &base_type);
  3168. GDScriptParser::DataType attr_type = p_subscript->attribute->get_datatype();
  3169. if (attr_type.is_set()) {
  3170. valid = true;
  3171. result_type = attr_type;
  3172. p_subscript->is_constant = p_subscript->attribute->is_constant;
  3173. p_subscript->reduced_value = p_subscript->attribute->reduced_value;
  3174. } else if (!base_type.is_constant) {
  3175. valid = base_type.kind != GDScriptParser::DataType::BUILTIN;
  3176. #ifdef DEBUG_ENABLED
  3177. if (valid) {
  3178. parser->push_warning(p_subscript, GDScriptWarning::UNSAFE_PROPERTY_ACCESS, p_subscript->attribute->name, base_type.to_string());
  3179. }
  3180. #endif
  3181. result_type.kind = GDScriptParser::DataType::VARIANT;
  3182. }
  3183. }
  3184. if (!valid) {
  3185. push_error(vformat(R"(Cannot find member "%s" in base "%s".)", p_subscript->attribute->name, type_from_metatype(base_type).to_string()), p_subscript->attribute);
  3186. result_type.kind = GDScriptParser::DataType::VARIANT;
  3187. }
  3188. } else {
  3189. if (p_subscript->index == nullptr) {
  3190. return;
  3191. }
  3192. reduce_expression(p_subscript->index);
  3193. if (p_subscript->base->is_constant && p_subscript->index->is_constant) {
  3194. // Just try to get it.
  3195. bool valid = false;
  3196. Variant value = p_subscript->base->reduced_value.get(p_subscript->index->reduced_value, &valid);
  3197. if (!valid) {
  3198. push_error(vformat(R"(Cannot get index "%s" from "%s".)", p_subscript->index->reduced_value, p_subscript->base->reduced_value), p_subscript->index);
  3199. } else {
  3200. p_subscript->is_constant = true;
  3201. p_subscript->reduced_value = value;
  3202. result_type = type_from_variant(value, p_subscript);
  3203. }
  3204. result_type.kind = GDScriptParser::DataType::VARIANT;
  3205. } else {
  3206. GDScriptParser::DataType base_type = p_subscript->base->get_datatype();
  3207. GDScriptParser::DataType index_type = p_subscript->index->get_datatype();
  3208. if (base_type.is_variant()) {
  3209. result_type.kind = GDScriptParser::DataType::VARIANT;
  3210. mark_node_unsafe(p_subscript);
  3211. } else {
  3212. if (base_type.kind == GDScriptParser::DataType::BUILTIN && !index_type.is_variant()) {
  3213. // Check if indexing is valid.
  3214. bool error = index_type.kind != GDScriptParser::DataType::BUILTIN && base_type.builtin_type != Variant::DICTIONARY;
  3215. if (!error) {
  3216. switch (base_type.builtin_type) {
  3217. // Expect int or real as index.
  3218. case Variant::PACKED_BYTE_ARRAY:
  3219. case Variant::PACKED_COLOR_ARRAY:
  3220. case Variant::PACKED_FLOAT32_ARRAY:
  3221. case Variant::PACKED_FLOAT64_ARRAY:
  3222. case Variant::PACKED_INT32_ARRAY:
  3223. case Variant::PACKED_INT64_ARRAY:
  3224. case Variant::PACKED_STRING_ARRAY:
  3225. case Variant::PACKED_VECTOR2_ARRAY:
  3226. case Variant::PACKED_VECTOR3_ARRAY:
  3227. case Variant::ARRAY:
  3228. case Variant::STRING:
  3229. error = index_type.builtin_type != Variant::INT && index_type.builtin_type != Variant::FLOAT;
  3230. break;
  3231. // Expect String only.
  3232. case Variant::RECT2:
  3233. case Variant::RECT2I:
  3234. case Variant::PLANE:
  3235. case Variant::QUATERNION:
  3236. case Variant::AABB:
  3237. case Variant::OBJECT:
  3238. error = index_type.builtin_type != Variant::STRING && index_type.builtin_type != Variant::STRING_NAME;
  3239. break;
  3240. // Expect String or number.
  3241. case Variant::BASIS:
  3242. case Variant::VECTOR2:
  3243. case Variant::VECTOR2I:
  3244. case Variant::VECTOR3:
  3245. case Variant::VECTOR3I:
  3246. case Variant::VECTOR4:
  3247. case Variant::VECTOR4I:
  3248. case Variant::TRANSFORM2D:
  3249. case Variant::TRANSFORM3D:
  3250. case Variant::PROJECTION:
  3251. error = index_type.builtin_type != Variant::INT && index_type.builtin_type != Variant::FLOAT &&
  3252. index_type.builtin_type != Variant::STRING && index_type.builtin_type != Variant::STRING_NAME;
  3253. break;
  3254. // Expect String or int.
  3255. case Variant::COLOR:
  3256. error = index_type.builtin_type != Variant::INT && index_type.builtin_type != Variant::STRING && index_type.builtin_type != Variant::STRING_NAME;
  3257. break;
  3258. // Don't support indexing, but we will check it later.
  3259. case Variant::RID:
  3260. case Variant::BOOL:
  3261. case Variant::CALLABLE:
  3262. case Variant::FLOAT:
  3263. case Variant::INT:
  3264. case Variant::NIL:
  3265. case Variant::NODE_PATH:
  3266. case Variant::SIGNAL:
  3267. case Variant::STRING_NAME:
  3268. break;
  3269. // Here for completeness.
  3270. case Variant::DICTIONARY:
  3271. case Variant::VARIANT_MAX:
  3272. break;
  3273. }
  3274. if (error) {
  3275. push_error(vformat(R"(Invalid index type "%s" for a base of type "%s".)", index_type.to_string(), base_type.to_string()), p_subscript->index);
  3276. }
  3277. }
  3278. } else if (base_type.kind != GDScriptParser::DataType::BUILTIN && !index_type.is_variant()) {
  3279. if (index_type.builtin_type != Variant::STRING && index_type.builtin_type != Variant::STRING_NAME) {
  3280. push_error(vformat(R"(Only String or StringName can be used as index for type "%s", but received a "%s".)", base_type.to_string(), index_type.to_string()), p_subscript->index);
  3281. }
  3282. }
  3283. // Check resulting type if possible.
  3284. result_type.builtin_type = Variant::NIL;
  3285. result_type.kind = GDScriptParser::DataType::BUILTIN;
  3286. result_type.type_source = base_type.is_hard_type() ? GDScriptParser::DataType::ANNOTATED_INFERRED : GDScriptParser::DataType::INFERRED;
  3287. if (base_type.kind != GDScriptParser::DataType::BUILTIN) {
  3288. base_type.builtin_type = Variant::OBJECT;
  3289. }
  3290. switch (base_type.builtin_type) {
  3291. // Can't index at all.
  3292. case Variant::RID:
  3293. case Variant::BOOL:
  3294. case Variant::CALLABLE:
  3295. case Variant::FLOAT:
  3296. case Variant::INT:
  3297. case Variant::NIL:
  3298. case Variant::NODE_PATH:
  3299. case Variant::SIGNAL:
  3300. case Variant::STRING_NAME:
  3301. result_type.kind = GDScriptParser::DataType::VARIANT;
  3302. push_error(vformat(R"(Cannot use subscript operator on a base of type "%s".)", base_type.to_string()), p_subscript->base);
  3303. break;
  3304. // Return int.
  3305. case Variant::PACKED_BYTE_ARRAY:
  3306. case Variant::PACKED_INT32_ARRAY:
  3307. case Variant::PACKED_INT64_ARRAY:
  3308. case Variant::VECTOR2I:
  3309. case Variant::VECTOR3I:
  3310. case Variant::VECTOR4I:
  3311. result_type.builtin_type = Variant::INT;
  3312. break;
  3313. // Return float.
  3314. case Variant::PACKED_FLOAT32_ARRAY:
  3315. case Variant::PACKED_FLOAT64_ARRAY:
  3316. case Variant::VECTOR2:
  3317. case Variant::VECTOR3:
  3318. case Variant::VECTOR4:
  3319. case Variant::QUATERNION:
  3320. result_type.builtin_type = Variant::FLOAT;
  3321. break;
  3322. // Return Color.
  3323. case Variant::PACKED_COLOR_ARRAY:
  3324. result_type.builtin_type = Variant::COLOR;
  3325. break;
  3326. // Return String.
  3327. case Variant::PACKED_STRING_ARRAY:
  3328. case Variant::STRING:
  3329. result_type.builtin_type = Variant::STRING;
  3330. break;
  3331. // Return Vector2.
  3332. case Variant::PACKED_VECTOR2_ARRAY:
  3333. case Variant::TRANSFORM2D:
  3334. case Variant::RECT2:
  3335. result_type.builtin_type = Variant::VECTOR2;
  3336. break;
  3337. // Return Vector2I.
  3338. case Variant::RECT2I:
  3339. result_type.builtin_type = Variant::VECTOR2I;
  3340. break;
  3341. // Return Vector3.
  3342. case Variant::PACKED_VECTOR3_ARRAY:
  3343. case Variant::AABB:
  3344. case Variant::BASIS:
  3345. result_type.builtin_type = Variant::VECTOR3;
  3346. break;
  3347. // Depends on the index.
  3348. case Variant::TRANSFORM3D:
  3349. case Variant::PROJECTION:
  3350. case Variant::PLANE:
  3351. case Variant::COLOR:
  3352. case Variant::DICTIONARY:
  3353. case Variant::OBJECT:
  3354. result_type.kind = GDScriptParser::DataType::VARIANT;
  3355. result_type.type_source = GDScriptParser::DataType::UNDETECTED;
  3356. break;
  3357. // Can have an element type.
  3358. case Variant::ARRAY:
  3359. if (base_type.has_container_element_type()) {
  3360. result_type = base_type.get_container_element_type();
  3361. result_type.type_source = base_type.type_source;
  3362. } else {
  3363. result_type.kind = GDScriptParser::DataType::VARIANT;
  3364. result_type.type_source = GDScriptParser::DataType::UNDETECTED;
  3365. }
  3366. break;
  3367. // Here for completeness.
  3368. case Variant::VARIANT_MAX:
  3369. break;
  3370. }
  3371. }
  3372. }
  3373. }
  3374. p_subscript->set_datatype(result_type);
  3375. }
  3376. void GDScriptAnalyzer::reduce_ternary_op(GDScriptParser::TernaryOpNode *p_ternary_op) {
  3377. reduce_expression(p_ternary_op->condition);
  3378. reduce_expression(p_ternary_op->true_expr);
  3379. reduce_expression(p_ternary_op->false_expr);
  3380. GDScriptParser::DataType result;
  3381. if (p_ternary_op->condition && p_ternary_op->condition->is_constant && p_ternary_op->true_expr->is_constant && p_ternary_op->false_expr && p_ternary_op->false_expr->is_constant) {
  3382. p_ternary_op->is_constant = true;
  3383. if (p_ternary_op->condition->reduced_value.booleanize()) {
  3384. p_ternary_op->reduced_value = p_ternary_op->true_expr->reduced_value;
  3385. } else {
  3386. p_ternary_op->reduced_value = p_ternary_op->false_expr->reduced_value;
  3387. }
  3388. }
  3389. GDScriptParser::DataType true_type;
  3390. if (p_ternary_op->true_expr) {
  3391. true_type = p_ternary_op->true_expr->get_datatype();
  3392. } else {
  3393. true_type.kind = GDScriptParser::DataType::VARIANT;
  3394. }
  3395. GDScriptParser::DataType false_type;
  3396. if (p_ternary_op->false_expr) {
  3397. false_type = p_ternary_op->false_expr->get_datatype();
  3398. } else {
  3399. false_type.kind = GDScriptParser::DataType::VARIANT;
  3400. }
  3401. if (true_type.is_variant() || false_type.is_variant()) {
  3402. result.kind = GDScriptParser::DataType::VARIANT;
  3403. } else {
  3404. result = true_type;
  3405. if (!is_type_compatible(true_type, false_type)) {
  3406. result = false_type;
  3407. if (!is_type_compatible(false_type, true_type)) {
  3408. result.type_source = GDScriptParser::DataType::UNDETECTED;
  3409. result.kind = GDScriptParser::DataType::VARIANT;
  3410. #ifdef DEBUG_ENABLED
  3411. parser->push_warning(p_ternary_op, GDScriptWarning::INCOMPATIBLE_TERNARY);
  3412. #endif
  3413. }
  3414. }
  3415. }
  3416. p_ternary_op->set_datatype(result);
  3417. }
  3418. void GDScriptAnalyzer::reduce_unary_op(GDScriptParser::UnaryOpNode *p_unary_op) {
  3419. reduce_expression(p_unary_op->operand);
  3420. GDScriptParser::DataType result;
  3421. if (p_unary_op->operand == nullptr) {
  3422. result.kind = GDScriptParser::DataType::VARIANT;
  3423. p_unary_op->set_datatype(result);
  3424. return;
  3425. }
  3426. GDScriptParser::DataType operand_type = p_unary_op->operand->get_datatype();
  3427. if (p_unary_op->operand->is_constant) {
  3428. p_unary_op->is_constant = true;
  3429. p_unary_op->reduced_value = Variant::evaluate(p_unary_op->variant_op, p_unary_op->operand->reduced_value, Variant());
  3430. result = type_from_variant(p_unary_op->reduced_value, p_unary_op);
  3431. }
  3432. if (operand_type.is_variant()) {
  3433. result.kind = GDScriptParser::DataType::VARIANT;
  3434. mark_node_unsafe(p_unary_op);
  3435. } else {
  3436. bool valid = false;
  3437. result = get_operation_type(p_unary_op->variant_op, operand_type, valid, p_unary_op);
  3438. if (!valid) {
  3439. push_error(vformat(R"(Invalid operand of type "%s" for unary operator "%s".)", operand_type.to_string(), Variant::get_operator_name(p_unary_op->variant_op)), p_unary_op);
  3440. }
  3441. }
  3442. p_unary_op->set_datatype(result);
  3443. }
  3444. void GDScriptAnalyzer::const_fold_array(GDScriptParser::ArrayNode *p_array) {
  3445. bool all_is_constant = true;
  3446. for (int i = 0; i < p_array->elements.size(); i++) {
  3447. GDScriptParser::ExpressionNode *element = p_array->elements[i];
  3448. if (element->type == GDScriptParser::Node::ARRAY) {
  3449. const_fold_array(static_cast<GDScriptParser::ArrayNode *>(element));
  3450. } else if (element->type == GDScriptParser::Node::DICTIONARY) {
  3451. const_fold_dictionary(static_cast<GDScriptParser::DictionaryNode *>(element));
  3452. }
  3453. all_is_constant = all_is_constant && element->is_constant;
  3454. if (!all_is_constant) {
  3455. return;
  3456. }
  3457. }
  3458. Array array;
  3459. array.resize(p_array->elements.size());
  3460. for (int i = 0; i < p_array->elements.size(); i++) {
  3461. array[i] = p_array->elements[i]->reduced_value;
  3462. }
  3463. p_array->is_constant = true;
  3464. p_array->reduced_value = array;
  3465. }
  3466. void GDScriptAnalyzer::const_fold_dictionary(GDScriptParser::DictionaryNode *p_dictionary) {
  3467. bool all_is_constant = true;
  3468. for (int i = 0; i < p_dictionary->elements.size(); i++) {
  3469. const GDScriptParser::DictionaryNode::Pair &element = p_dictionary->elements[i];
  3470. if (element.value->type == GDScriptParser::Node::ARRAY) {
  3471. const_fold_array(static_cast<GDScriptParser::ArrayNode *>(element.value));
  3472. } else if (element.value->type == GDScriptParser::Node::DICTIONARY) {
  3473. const_fold_dictionary(static_cast<GDScriptParser::DictionaryNode *>(element.value));
  3474. }
  3475. all_is_constant = all_is_constant && element.key->is_constant && element.value->is_constant;
  3476. if (!all_is_constant) {
  3477. return;
  3478. }
  3479. }
  3480. Dictionary dict;
  3481. for (int i = 0; i < p_dictionary->elements.size(); i++) {
  3482. const GDScriptParser::DictionaryNode::Pair &element = p_dictionary->elements[i];
  3483. dict[element.key->reduced_value] = element.value->reduced_value;
  3484. }
  3485. p_dictionary->is_constant = true;
  3486. p_dictionary->reduced_value = dict;
  3487. }
  3488. GDScriptParser::DataType GDScriptAnalyzer::type_from_variant(const Variant &p_value, const GDScriptParser::Node *p_source) {
  3489. GDScriptParser::DataType result;
  3490. result.is_constant = true;
  3491. result.kind = GDScriptParser::DataType::BUILTIN;
  3492. result.builtin_type = p_value.get_type();
  3493. result.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT; // Constant has explicit type.
  3494. if (p_value.get_type() == Variant::NIL) {
  3495. // A null value is a variant, not void.
  3496. result.kind = GDScriptParser::DataType::VARIANT;
  3497. } else if (p_value.get_type() == Variant::OBJECT) {
  3498. // Object is treated as a native type, not a builtin type.
  3499. result.kind = GDScriptParser::DataType::NATIVE;
  3500. Object *obj = p_value;
  3501. if (!obj) {
  3502. return GDScriptParser::DataType();
  3503. }
  3504. result.native_type = obj->get_class_name();
  3505. Ref<Script> scr = p_value; // Check if value is a script itself.
  3506. if (scr.is_valid()) {
  3507. result.is_meta_type = true;
  3508. } else {
  3509. result.is_meta_type = false;
  3510. scr = obj->get_script();
  3511. }
  3512. if (scr.is_valid()) {
  3513. result.script_path = scr->get_path();
  3514. Ref<GDScript> gds = scr;
  3515. if (gds.is_valid()) {
  3516. result.kind = GDScriptParser::DataType::CLASS;
  3517. // This might be an inner class, so we want to get the parser for the root.
  3518. // But still get the inner class from that tree.
  3519. GDScript *current = gds.ptr();
  3520. List<StringName> class_chain;
  3521. while (current->_owner) {
  3522. // Push to front so it's in reverse.
  3523. class_chain.push_front(current->name);
  3524. current = current->_owner;
  3525. }
  3526. Ref<GDScriptParserRef> ref = get_parser_for(current->get_path());
  3527. if (ref.is_null()) {
  3528. push_error("Could not find script in path.", p_source);
  3529. GDScriptParser::DataType error_type;
  3530. error_type.kind = GDScriptParser::DataType::VARIANT;
  3531. return error_type;
  3532. }
  3533. ref->raise_status(GDScriptParserRef::INHERITANCE_SOLVED);
  3534. GDScriptParser::ClassNode *found = ref->get_parser()->head;
  3535. for (const StringName &E : class_chain) {
  3536. if (!found->has_member(E)) {
  3537. return GDScriptParser::DataType();
  3538. }
  3539. if (found->get_member(E).type != GDScriptParser::ClassNode::Member::CLASS) {
  3540. return GDScriptParser::DataType();
  3541. }
  3542. resolve_class_member(found, E, p_source);
  3543. found = found->get_member(E).m_class;
  3544. }
  3545. result.class_type = found;
  3546. result.script_path = ref->get_parser()->script_path;
  3547. } else {
  3548. result.kind = GDScriptParser::DataType::SCRIPT;
  3549. result.native_type = scr->get_instance_base_type();
  3550. }
  3551. result.script_type = scr;
  3552. } else {
  3553. result.kind = GDScriptParser::DataType::NATIVE;
  3554. if (result.native_type == GDScriptNativeClass::get_class_static()) {
  3555. result.is_meta_type = true;
  3556. }
  3557. }
  3558. }
  3559. return result;
  3560. }
  3561. GDScriptParser::DataType GDScriptAnalyzer::type_from_metatype(const GDScriptParser::DataType &p_meta_type) const {
  3562. GDScriptParser::DataType result = p_meta_type;
  3563. result.is_meta_type = false;
  3564. result.is_constant = false;
  3565. if (p_meta_type.kind == GDScriptParser::DataType::ENUM) {
  3566. result.builtin_type = Variant::INT;
  3567. }
  3568. return result;
  3569. }
  3570. GDScriptParser::DataType GDScriptAnalyzer::type_from_property(const PropertyInfo &p_property) const {
  3571. GDScriptParser::DataType result;
  3572. result.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
  3573. if (p_property.type == Variant::NIL && (p_property.usage & PROPERTY_USAGE_NIL_IS_VARIANT)) {
  3574. // Variant
  3575. result.kind = GDScriptParser::DataType::VARIANT;
  3576. return result;
  3577. }
  3578. result.builtin_type = p_property.type;
  3579. if (p_property.type == Variant::OBJECT) {
  3580. result.kind = GDScriptParser::DataType::NATIVE;
  3581. result.native_type = p_property.class_name == StringName() ? SNAME("Object") : p_property.class_name;
  3582. } else {
  3583. result.kind = GDScriptParser::DataType::BUILTIN;
  3584. result.builtin_type = p_property.type;
  3585. if (p_property.type == Variant::ARRAY && p_property.hint == PROPERTY_HINT_ARRAY_TYPE) {
  3586. // Check element type.
  3587. StringName elem_type_name = p_property.hint_string;
  3588. GDScriptParser::DataType elem_type;
  3589. elem_type.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
  3590. Variant::Type elem_builtin_type = GDScriptParser::get_builtin_type(elem_type_name);
  3591. if (elem_builtin_type < Variant::VARIANT_MAX) {
  3592. // Builtin type.
  3593. elem_type.kind = GDScriptParser::DataType::BUILTIN;
  3594. elem_type.builtin_type = elem_builtin_type;
  3595. } else if (class_exists(elem_type_name)) {
  3596. elem_type.kind = GDScriptParser::DataType::NATIVE;
  3597. elem_type.builtin_type = Variant::OBJECT;
  3598. elem_type.native_type = p_property.hint_string;
  3599. } else if (ScriptServer::is_global_class(elem_type_name)) {
  3600. // Just load this as it shouldn't be a GDScript.
  3601. Ref<Script> script = ResourceLoader::load(ScriptServer::get_global_class_path(elem_type_name));
  3602. elem_type.kind = GDScriptParser::DataType::SCRIPT;
  3603. elem_type.builtin_type = Variant::OBJECT;
  3604. elem_type.native_type = script->get_instance_base_type();
  3605. elem_type.script_type = script;
  3606. } else {
  3607. ERR_FAIL_V_MSG(result, "Could not find element type from property hint of a typed array.");
  3608. }
  3609. elem_type.is_constant = false;
  3610. result.set_container_element_type(elem_type);
  3611. }
  3612. }
  3613. return result;
  3614. }
  3615. bool GDScriptAnalyzer::get_function_signature(GDScriptParser::Node *p_source, bool p_is_constructor, GDScriptParser::DataType p_base_type, const StringName &p_function, GDScriptParser::DataType &r_return_type, List<GDScriptParser::DataType> &r_par_types, int &r_default_arg_count, bool &r_static, bool &r_vararg) {
  3616. r_static = false;
  3617. r_vararg = false;
  3618. r_default_arg_count = 0;
  3619. StringName function_name = p_function;
  3620. if (p_base_type.kind == GDScriptParser::DataType::ENUM) {
  3621. if (p_base_type.is_meta_type) {
  3622. // Enum type can be treated as a dictionary value.
  3623. p_base_type.kind = GDScriptParser::DataType::BUILTIN;
  3624. p_base_type.builtin_type = Variant::DICTIONARY;
  3625. p_base_type.is_meta_type = false;
  3626. } else {
  3627. push_error("Cannot call function on enum value.", p_source);
  3628. return false;
  3629. }
  3630. }
  3631. if (p_base_type.kind == GDScriptParser::DataType::BUILTIN) {
  3632. // Construct a base type to get methods.
  3633. Callable::CallError err;
  3634. Variant dummy;
  3635. Variant::construct(p_base_type.builtin_type, dummy, nullptr, 0, err);
  3636. if (err.error != Callable::CallError::CALL_OK) {
  3637. ERR_FAIL_V_MSG(false, "Could not construct base Variant type.");
  3638. }
  3639. List<MethodInfo> methods;
  3640. dummy.get_method_list(&methods);
  3641. for (const MethodInfo &E : methods) {
  3642. if (E.name == p_function) {
  3643. function_signature_from_info(E, r_return_type, r_par_types, r_default_arg_count, r_static, r_vararg);
  3644. r_static = Variant::is_builtin_method_static(p_base_type.builtin_type, function_name);
  3645. return true;
  3646. }
  3647. }
  3648. return false;
  3649. }
  3650. if (p_is_constructor) {
  3651. function_name = "_init";
  3652. r_static = true;
  3653. }
  3654. GDScriptParser::ClassNode *base_class = p_base_type.class_type;
  3655. GDScriptParser::FunctionNode *found_function = nullptr;
  3656. while (found_function == nullptr && base_class != nullptr) {
  3657. if (base_class->has_member(function_name)) {
  3658. if (base_class->get_member(function_name).type != GDScriptParser::ClassNode::Member::FUNCTION) {
  3659. // TODO: If this is Callable it can have a better error message.
  3660. push_error(vformat(R"(Member "%s" is not a function.)", function_name), p_source);
  3661. return false;
  3662. }
  3663. resolve_class_member(base_class, function_name, p_source);
  3664. found_function = base_class->get_member(function_name).function;
  3665. }
  3666. resolve_class_inheritance(base_class, p_source);
  3667. base_class = base_class->base_type.class_type;
  3668. }
  3669. if (found_function != nullptr) {
  3670. r_static = p_is_constructor || found_function->is_static;
  3671. for (int i = 0; i < found_function->parameters.size(); i++) {
  3672. r_par_types.push_back(found_function->parameters[i]->get_datatype());
  3673. if (found_function->parameters[i]->default_value != nullptr) {
  3674. r_default_arg_count++;
  3675. }
  3676. }
  3677. r_return_type = found_function->get_datatype();
  3678. r_return_type.is_meta_type = false;
  3679. r_return_type.is_coroutine = found_function->is_coroutine;
  3680. return true;
  3681. }
  3682. Ref<Script> base_script = p_base_type.script_type;
  3683. while (base_script.is_valid() && base_script->has_method(function_name)) {
  3684. MethodInfo info = base_script->get_method_info(function_name);
  3685. if (!(info == MethodInfo())) {
  3686. return function_signature_from_info(info, r_return_type, r_par_types, r_default_arg_count, r_static, r_vararg);
  3687. }
  3688. base_script = base_script->get_base_script();
  3689. }
  3690. // If the base is a script, it might be trying to access members of the Script class itself.
  3691. if (p_base_type.is_meta_type && !p_is_constructor && (p_base_type.kind == GDScriptParser::DataType::SCRIPT || p_base_type.kind == GDScriptParser::DataType::CLASS)) {
  3692. MethodInfo info;
  3693. StringName script_class = p_base_type.kind == GDScriptParser::DataType::SCRIPT ? p_base_type.script_type->get_class_name() : StringName(GDScript::get_class_static());
  3694. if (ClassDB::get_method_info(script_class, function_name, &info)) {
  3695. return function_signature_from_info(info, r_return_type, r_par_types, r_default_arg_count, r_static, r_vararg);
  3696. }
  3697. }
  3698. StringName base_native = p_base_type.native_type;
  3699. #ifdef DEBUG_ENABLED
  3700. if (base_native != StringName()) {
  3701. // Empty native class might happen in some Script implementations.
  3702. // Just ignore it.
  3703. if (!class_exists(base_native)) {
  3704. ERR_FAIL_V_MSG(false, vformat("Native class %s used in script doesn't exist or isn't exposed.", base_native));
  3705. }
  3706. }
  3707. #endif
  3708. if (p_is_constructor) {
  3709. // Native types always have a default constructor.
  3710. r_return_type = p_base_type;
  3711. r_return_type.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
  3712. r_return_type.is_meta_type = false;
  3713. return true;
  3714. }
  3715. MethodInfo info;
  3716. if (ClassDB::get_method_info(base_native, function_name, &info)) {
  3717. bool valid = function_signature_from_info(info, r_return_type, r_par_types, r_default_arg_count, r_static, r_vararg);
  3718. if (valid && Engine::get_singleton()->has_singleton(base_native)) {
  3719. r_static = true;
  3720. }
  3721. return valid;
  3722. }
  3723. return false;
  3724. }
  3725. bool GDScriptAnalyzer::function_signature_from_info(const MethodInfo &p_info, GDScriptParser::DataType &r_return_type, List<GDScriptParser::DataType> &r_par_types, int &r_default_arg_count, bool &r_static, bool &r_vararg) {
  3726. r_return_type = type_from_property(p_info.return_val);
  3727. r_default_arg_count = p_info.default_arguments.size();
  3728. r_vararg = (p_info.flags & METHOD_FLAG_VARARG) != 0;
  3729. r_static = (p_info.flags & METHOD_FLAG_STATIC) != 0;
  3730. for (const PropertyInfo &E : p_info.arguments) {
  3731. r_par_types.push_back(type_from_property(E));
  3732. }
  3733. return true;
  3734. }
  3735. bool GDScriptAnalyzer::validate_call_arg(const MethodInfo &p_method, const GDScriptParser::CallNode *p_call) {
  3736. List<GDScriptParser::DataType> arg_types;
  3737. for (const PropertyInfo &E : p_method.arguments) {
  3738. arg_types.push_back(type_from_property(E));
  3739. }
  3740. return validate_call_arg(arg_types, p_method.default_arguments.size(), (p_method.flags & METHOD_FLAG_VARARG) != 0, p_call);
  3741. }
  3742. bool GDScriptAnalyzer::validate_call_arg(const List<GDScriptParser::DataType> &p_par_types, int p_default_args_count, bool p_is_vararg, const GDScriptParser::CallNode *p_call) {
  3743. bool valid = true;
  3744. if (p_call->arguments.size() < p_par_types.size() - p_default_args_count) {
  3745. push_error(vformat(R"*(Too few arguments for "%s()" call. Expected at least %d but received %d.)*", p_call->function_name, p_par_types.size() - p_default_args_count, p_call->arguments.size()), p_call);
  3746. valid = false;
  3747. }
  3748. if (!p_is_vararg && p_call->arguments.size() > p_par_types.size()) {
  3749. push_error(vformat(R"*(Too many arguments for "%s()" call. Expected at most %d but received %d.)*", p_call->function_name, p_par_types.size(), p_call->arguments.size()), p_call->arguments[p_par_types.size()]);
  3750. valid = false;
  3751. }
  3752. for (int i = 0; i < p_call->arguments.size(); i++) {
  3753. if (i >= p_par_types.size()) {
  3754. // Already on vararg place.
  3755. break;
  3756. }
  3757. GDScriptParser::DataType par_type = p_par_types[i];
  3758. GDScriptParser::DataType arg_type = p_call->arguments[i]->get_datatype();
  3759. if (arg_type.is_variant()) {
  3760. // Argument can be anything, so this is unsafe.
  3761. mark_node_unsafe(p_call->arguments[i]);
  3762. } else if (par_type.is_hard_type() && !is_type_compatible(par_type, arg_type, true)) {
  3763. // Supertypes are acceptable for dynamic compliance, but it's unsafe.
  3764. mark_node_unsafe(p_call);
  3765. if (!is_type_compatible(arg_type, par_type)) {
  3766. push_error(vformat(R"*(Invalid argument for "%s()" function: argument %d should be %s but is %s.)*",
  3767. p_call->function_name, i + 1, par_type.to_string(), arg_type.to_string()),
  3768. p_call->arguments[i]);
  3769. valid = false;
  3770. }
  3771. #ifdef DEBUG_ENABLED
  3772. } else {
  3773. if (par_type.kind == GDScriptParser::DataType::BUILTIN && par_type.builtin_type == Variant::INT && arg_type.kind == GDScriptParser::DataType::BUILTIN && arg_type.builtin_type == Variant::FLOAT) {
  3774. parser->push_warning(p_call, GDScriptWarning::NARROWING_CONVERSION, p_call->function_name);
  3775. }
  3776. #endif
  3777. }
  3778. }
  3779. return valid;
  3780. }
  3781. #ifdef DEBUG_ENABLED
  3782. bool GDScriptAnalyzer::is_shadowing(GDScriptParser::IdentifierNode *p_local, const String &p_context) {
  3783. const StringName &name = p_local->name;
  3784. GDScriptParser::DataType base = parser->current_class->get_datatype();
  3785. GDScriptParser::ClassNode *base_class = base.class_type;
  3786. {
  3787. List<MethodInfo> gdscript_funcs;
  3788. GDScriptLanguage::get_singleton()->get_public_functions(&gdscript_funcs);
  3789. for (MethodInfo &info : gdscript_funcs) {
  3790. if (info.name == name) {
  3791. parser->push_warning(p_local, GDScriptWarning::SHADOWED_GLOBAL_IDENTIFIER, p_context, name, "built-in function");
  3792. return true;
  3793. }
  3794. }
  3795. if (Variant::has_utility_function(name)) {
  3796. parser->push_warning(p_local, GDScriptWarning::SHADOWED_GLOBAL_IDENTIFIER, p_context, name, "built-in function");
  3797. return true;
  3798. } else if (ClassDB::class_exists(name)) {
  3799. parser->push_warning(p_local, GDScriptWarning::SHADOWED_GLOBAL_IDENTIFIER, p_context, name, "global class");
  3800. return true;
  3801. }
  3802. }
  3803. while (base_class != nullptr) {
  3804. if (base_class->has_member(name)) {
  3805. parser->push_warning(p_local, GDScriptWarning::SHADOWED_VARIABLE, p_context, p_local->name, base_class->get_member(name).get_type_name(), itos(base_class->get_member(name).get_line()));
  3806. return true;
  3807. }
  3808. base_class = base_class->base_type.class_type;
  3809. }
  3810. StringName parent = base.native_type;
  3811. while (parent != StringName()) {
  3812. ERR_FAIL_COND_V_MSG(!class_exists(parent), false, "Non-existent native base class.");
  3813. if (ClassDB::has_method(parent, name, true)) {
  3814. parser->push_warning(p_local, GDScriptWarning::SHADOWED_VARIABLE_BASE_CLASS, p_context, p_local->name, "method", parent);
  3815. return true;
  3816. } else if (ClassDB::has_signal(parent, name, true)) {
  3817. parser->push_warning(p_local, GDScriptWarning::SHADOWED_VARIABLE_BASE_CLASS, p_context, p_local->name, "signal", parent);
  3818. return true;
  3819. } else if (ClassDB::has_property(parent, name, true)) {
  3820. parser->push_warning(p_local, GDScriptWarning::SHADOWED_VARIABLE_BASE_CLASS, p_context, p_local->name, "property", parent);
  3821. return true;
  3822. } else if (ClassDB::has_integer_constant(parent, name, true)) {
  3823. parser->push_warning(p_local, GDScriptWarning::SHADOWED_VARIABLE_BASE_CLASS, p_context, p_local->name, "constant", parent);
  3824. return true;
  3825. } else if (ClassDB::has_enum(parent, name, true)) {
  3826. parser->push_warning(p_local, GDScriptWarning::SHADOWED_VARIABLE_BASE_CLASS, p_context, p_local->name, "enum", parent);
  3827. return true;
  3828. }
  3829. parent = ClassDB::get_parent_class(parent);
  3830. }
  3831. return false;
  3832. }
  3833. #endif
  3834. GDScriptParser::DataType GDScriptAnalyzer::get_operation_type(Variant::Operator p_operation, const GDScriptParser::DataType &p_a, bool &r_valid, const GDScriptParser::Node *p_source) {
  3835. // Unary version.
  3836. GDScriptParser::DataType nil_type;
  3837. nil_type.builtin_type = Variant::NIL;
  3838. nil_type.type_source = GDScriptParser::DataType::ANNOTATED_INFERRED;
  3839. return get_operation_type(p_operation, p_a, nil_type, r_valid, p_source);
  3840. }
  3841. GDScriptParser::DataType GDScriptAnalyzer::get_operation_type(Variant::Operator p_operation, const GDScriptParser::DataType &p_a, const GDScriptParser::DataType &p_b, bool &r_valid, const GDScriptParser::Node *p_source) {
  3842. GDScriptParser::DataType result;
  3843. result.kind = GDScriptParser::DataType::VARIANT;
  3844. Variant::Type a_type = p_a.builtin_type;
  3845. Variant::Type b_type = p_b.builtin_type;
  3846. if (p_a.kind == GDScriptParser::DataType::ENUM) {
  3847. if (p_a.is_meta_type) {
  3848. a_type = Variant::DICTIONARY;
  3849. } else {
  3850. a_type = Variant::INT;
  3851. }
  3852. }
  3853. if (p_b.kind == GDScriptParser::DataType::ENUM) {
  3854. if (p_b.is_meta_type) {
  3855. b_type = Variant::DICTIONARY;
  3856. } else {
  3857. b_type = Variant::INT;
  3858. }
  3859. }
  3860. Variant::ValidatedOperatorEvaluator op_eval = Variant::get_validated_operator_evaluator(p_operation, a_type, b_type);
  3861. bool hard_operation = p_a.is_hard_type() && p_b.is_hard_type();
  3862. bool validated = op_eval != nullptr;
  3863. if (hard_operation && !validated) {
  3864. r_valid = false;
  3865. return result;
  3866. } else if (hard_operation && validated) {
  3867. r_valid = true;
  3868. result.type_source = GDScriptParser::DataType::ANNOTATED_INFERRED;
  3869. result.kind = GDScriptParser::DataType::BUILTIN;
  3870. result.builtin_type = Variant::get_operator_return_type(p_operation, a_type, b_type);
  3871. } else if (!hard_operation && !validated) {
  3872. r_valid = true;
  3873. result.type_source = GDScriptParser::DataType::UNDETECTED;
  3874. result.kind = GDScriptParser::DataType::VARIANT;
  3875. result.builtin_type = Variant::NIL;
  3876. } else if (!hard_operation && validated) {
  3877. r_valid = true;
  3878. result.type_source = GDScriptParser::DataType::INFERRED;
  3879. result.kind = GDScriptParser::DataType::BUILTIN;
  3880. result.builtin_type = Variant::get_operator_return_type(p_operation, a_type, b_type);
  3881. }
  3882. return result;
  3883. }
  3884. // TODO: Add safe/unsafe return variable (for variant cases)
  3885. bool GDScriptAnalyzer::is_type_compatible(const GDScriptParser::DataType &p_target, const GDScriptParser::DataType &p_source, bool p_allow_implicit_conversion, const GDScriptParser::Node *p_source_node) {
  3886. // These return "true" so it doesn't affect users negatively.
  3887. ERR_FAIL_COND_V_MSG(!p_target.is_set(), true, "Parser bug (please report): Trying to check compatibility of unset target type");
  3888. ERR_FAIL_COND_V_MSG(!p_source.is_set(), true, "Parser bug (please report): Trying to check compatibility of unset value type");
  3889. if (p_target.kind == GDScriptParser::DataType::VARIANT) {
  3890. // Variant can receive anything.
  3891. return true;
  3892. }
  3893. if (p_source.kind == GDScriptParser::DataType::VARIANT) {
  3894. // TODO: This is acceptable but unsafe. Make sure unsafe line is set.
  3895. return true;
  3896. }
  3897. if (p_target.kind == GDScriptParser::DataType::BUILTIN) {
  3898. bool valid = p_source.kind == GDScriptParser::DataType::BUILTIN && p_target.builtin_type == p_source.builtin_type;
  3899. if (!valid && p_allow_implicit_conversion) {
  3900. valid = Variant::can_convert_strict(p_source.builtin_type, p_target.builtin_type);
  3901. }
  3902. if (!valid && p_target.builtin_type == Variant::INT && p_source.kind == GDScriptParser::DataType::ENUM && !p_source.is_meta_type) {
  3903. // Enum value is also integer.
  3904. valid = true;
  3905. }
  3906. if (valid && p_target.builtin_type == Variant::ARRAY && p_source.builtin_type == Variant::ARRAY) {
  3907. // Check the element type.
  3908. if (p_target.has_container_element_type()) {
  3909. if (!p_source.has_container_element_type()) {
  3910. // TODO: Maybe this is valid but unsafe?
  3911. // Variant array can't be appended to typed array.
  3912. valid = false;
  3913. } else {
  3914. valid = is_type_compatible(p_target.get_container_element_type(), p_source.get_container_element_type(), p_allow_implicit_conversion);
  3915. }
  3916. }
  3917. }
  3918. return valid;
  3919. }
  3920. if (p_target.kind == GDScriptParser::DataType::ENUM) {
  3921. if (p_source.kind == GDScriptParser::DataType::BUILTIN && p_source.builtin_type == Variant::INT) {
  3922. #ifdef DEBUG_ENABLED
  3923. if (p_source_node) {
  3924. parser->push_warning(p_source_node, GDScriptWarning::INT_ASSIGNED_TO_ENUM);
  3925. }
  3926. #endif
  3927. return true;
  3928. }
  3929. if (p_source.kind == GDScriptParser::DataType::ENUM) {
  3930. if (p_source.native_type == p_target.native_type) {
  3931. return true;
  3932. }
  3933. }
  3934. return false;
  3935. }
  3936. // From here on the target type is an object, so we have to test polymorphism.
  3937. if (p_source.kind == GDScriptParser::DataType::BUILTIN && p_source.builtin_type == Variant::NIL) {
  3938. // null is acceptable in object.
  3939. return true;
  3940. }
  3941. StringName src_native;
  3942. Ref<Script> src_script;
  3943. const GDScriptParser::ClassNode *src_class = nullptr;
  3944. switch (p_source.kind) {
  3945. case GDScriptParser::DataType::NATIVE:
  3946. if (p_target.kind != GDScriptParser::DataType::NATIVE) {
  3947. // Non-native class cannot be supertype of native.
  3948. return false;
  3949. }
  3950. if (p_source.is_meta_type) {
  3951. src_native = GDScriptNativeClass::get_class_static();
  3952. } else {
  3953. src_native = p_source.native_type;
  3954. }
  3955. break;
  3956. case GDScriptParser::DataType::SCRIPT:
  3957. if (p_target.kind == GDScriptParser::DataType::CLASS) {
  3958. // A script type cannot be a subtype of a GDScript class.
  3959. return false;
  3960. }
  3961. if (p_source.is_meta_type) {
  3962. src_native = p_source.script_type->get_class_name();
  3963. } else {
  3964. src_script = p_source.script_type;
  3965. src_native = src_script->get_instance_base_type();
  3966. }
  3967. break;
  3968. case GDScriptParser::DataType::CLASS:
  3969. if (p_source.is_meta_type) {
  3970. src_native = GDScript::get_class_static();
  3971. } else {
  3972. src_class = p_source.class_type;
  3973. const GDScriptParser::ClassNode *base = src_class;
  3974. while (base->base_type.kind == GDScriptParser::DataType::CLASS) {
  3975. base = base->base_type.class_type;
  3976. }
  3977. src_native = base->base_type.native_type;
  3978. src_script = base->base_type.script_type;
  3979. }
  3980. break;
  3981. case GDScriptParser::DataType::VARIANT:
  3982. case GDScriptParser::DataType::BUILTIN:
  3983. case GDScriptParser::DataType::ENUM:
  3984. case GDScriptParser::DataType::RESOLVING:
  3985. case GDScriptParser::DataType::UNRESOLVED:
  3986. break; // Already solved before.
  3987. }
  3988. switch (p_target.kind) {
  3989. case GDScriptParser::DataType::NATIVE: {
  3990. if (p_target.is_meta_type) {
  3991. return ClassDB::is_parent_class(src_native, GDScriptNativeClass::get_class_static());
  3992. }
  3993. return ClassDB::is_parent_class(src_native, p_target.native_type);
  3994. }
  3995. case GDScriptParser::DataType::SCRIPT:
  3996. if (p_target.is_meta_type) {
  3997. return ClassDB::is_parent_class(src_native, p_target.script_type->get_class_name());
  3998. }
  3999. while (src_script.is_valid()) {
  4000. if (src_script == p_target.script_type) {
  4001. return true;
  4002. }
  4003. src_script = src_script->get_base_script();
  4004. }
  4005. return false;
  4006. case GDScriptParser::DataType::CLASS:
  4007. if (p_target.is_meta_type) {
  4008. return ClassDB::is_parent_class(src_native, GDScript::get_class_static());
  4009. }
  4010. while (src_class != nullptr) {
  4011. if (src_class->fqcn == p_target.class_type->fqcn) {
  4012. return true;
  4013. }
  4014. src_class = src_class->base_type.class_type;
  4015. }
  4016. return false;
  4017. case GDScriptParser::DataType::VARIANT:
  4018. case GDScriptParser::DataType::BUILTIN:
  4019. case GDScriptParser::DataType::ENUM:
  4020. case GDScriptParser::DataType::RESOLVING:
  4021. case GDScriptParser::DataType::UNRESOLVED:
  4022. break; // Already solved before.
  4023. }
  4024. return false;
  4025. }
  4026. void GDScriptAnalyzer::push_error(const String &p_message, const GDScriptParser::Node *p_origin) {
  4027. mark_node_unsafe(p_origin);
  4028. parser->push_error(p_message, p_origin);
  4029. }
  4030. void GDScriptAnalyzer::mark_node_unsafe(const GDScriptParser::Node *p_node) {
  4031. #ifdef DEBUG_ENABLED
  4032. if (p_node == nullptr) {
  4033. return;
  4034. }
  4035. for (int i = p_node->start_line; i <= p_node->end_line; i++) {
  4036. parser->unsafe_lines.insert(i);
  4037. }
  4038. #endif
  4039. }
  4040. void GDScriptAnalyzer::mark_lambda_use_self() {
  4041. for (GDScriptParser::LambdaNode *lambda : lambda_stack) {
  4042. lambda->use_self = true;
  4043. }
  4044. }
  4045. bool GDScriptAnalyzer::class_exists(const StringName &p_class) const {
  4046. return ClassDB::class_exists(p_class) && ClassDB::is_class_exposed(p_class);
  4047. }
  4048. Ref<GDScriptParserRef> GDScriptAnalyzer::get_parser_for(const String &p_path) {
  4049. Ref<GDScriptParserRef> ref;
  4050. if (depended_parsers.has(p_path)) {
  4051. ref = depended_parsers[p_path];
  4052. } else {
  4053. Error err = OK;
  4054. ref = GDScriptCache::get_parser(p_path, GDScriptParserRef::EMPTY, err, parser->script_path);
  4055. if (ref.is_valid()) {
  4056. depended_parsers[p_path] = ref;
  4057. }
  4058. }
  4059. return ref;
  4060. }
  4061. Error GDScriptAnalyzer::resolve_inheritance() {
  4062. return resolve_class_inheritance(parser->head, true);
  4063. }
  4064. Error GDScriptAnalyzer::resolve_interface() {
  4065. resolve_class_interface(parser->head, true);
  4066. return parser->errors.is_empty() ? OK : ERR_PARSE_ERROR;
  4067. }
  4068. Error GDScriptAnalyzer::resolve_body() {
  4069. resolve_class_body(parser->head, true);
  4070. return parser->errors.is_empty() ? OK : ERR_PARSE_ERROR;
  4071. }
  4072. Error GDScriptAnalyzer::resolve_dependencies() {
  4073. for (KeyValue<String, Ref<GDScriptParserRef>> &K : depended_parsers) {
  4074. if (K.value.is_null()) {
  4075. return ERR_PARSE_ERROR;
  4076. }
  4077. K.value->raise_status(GDScriptParserRef::INHERITANCE_SOLVED);
  4078. }
  4079. return parser->errors.is_empty() ? OK : ERR_PARSE_ERROR;
  4080. }
  4081. Error GDScriptAnalyzer::analyze() {
  4082. parser->errors.clear();
  4083. Error err = OK;
  4084. err = resolve_inheritance();
  4085. if (err) {
  4086. return err;
  4087. }
  4088. resolve_interface();
  4089. resolve_body();
  4090. if (!parser->errors.is_empty()) {
  4091. return ERR_PARSE_ERROR;
  4092. }
  4093. return resolve_dependencies();
  4094. }
  4095. GDScriptAnalyzer::GDScriptAnalyzer(GDScriptParser *p_parser) {
  4096. parser = p_parser;
  4097. }