gdscript_editor.cpp 149 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556255725582559256025612562256325642565256625672568256925702571257225732574257525762577257825792580258125822583258425852586258725882589259025912592259325942595259625972598259926002601260226032604260526062607260826092610261126122613261426152616261726182619262026212622262326242625262626272628262926302631263226332634263526362637263826392640264126422643264426452646264726482649265026512652265326542655265626572658265926602661266226632664266526662667266826692670267126722673267426752676267726782679268026812682268326842685268626872688268926902691269226932694269526962697269826992700270127022703270427052706270727082709271027112712271327142715271627172718271927202721272227232724272527262727272827292730273127322733273427352736273727382739274027412742274327442745274627472748274927502751275227532754275527562757275827592760276127622763276427652766276727682769277027712772277327742775277627772778277927802781278227832784278527862787278827892790279127922793279427952796279727982799280028012802280328042805280628072808280928102811281228132814281528162817281828192820282128222823282428252826282728282829283028312832283328342835283628372838283928402841284228432844284528462847284828492850285128522853285428552856285728582859286028612862286328642865286628672868286928702871287228732874287528762877287828792880288128822883288428852886288728882889289028912892289328942895289628972898289929002901290229032904290529062907290829092910291129122913291429152916291729182919292029212922292329242925292629272928292929302931293229332934293529362937293829392940294129422943294429452946294729482949295029512952295329542955295629572958295929602961296229632964296529662967296829692970297129722973297429752976297729782979298029812982298329842985298629872988298929902991299229932994299529962997299829993000300130023003300430053006300730083009301030113012301330143015301630173018301930203021302230233024302530263027302830293030303130323033303430353036303730383039304030413042304330443045304630473048304930503051305230533054305530563057305830593060306130623063306430653066306730683069307030713072307330743075307630773078307930803081308230833084308530863087308830893090309130923093309430953096309730983099310031013102310331043105310631073108310931103111311231133114311531163117311831193120312131223123312431253126312731283129313031313132313331343135313631373138313931403141314231433144314531463147314831493150315131523153315431553156315731583159316031613162316331643165316631673168316931703171317231733174317531763177317831793180318131823183318431853186318731883189319031913192319331943195319631973198319932003201320232033204320532063207320832093210321132123213321432153216321732183219322032213222322332243225322632273228322932303231323232333234323532363237323832393240324132423243324432453246324732483249325032513252325332543255325632573258325932603261326232633264326532663267326832693270327132723273327432753276327732783279328032813282328332843285328632873288328932903291329232933294329532963297329832993300330133023303330433053306330733083309331033113312331333143315331633173318331933203321332233233324332533263327332833293330333133323333333433353336333733383339334033413342334333443345334633473348334933503351335233533354335533563357335833593360336133623363336433653366336733683369337033713372337333743375337633773378337933803381338233833384338533863387338833893390339133923393339433953396339733983399340034013402340334043405340634073408340934103411341234133414341534163417341834193420342134223423342434253426342734283429343034313432343334343435343634373438343934403441344234433444344534463447344834493450345134523453345434553456345734583459346034613462346334643465346634673468346934703471347234733474347534763477347834793480348134823483348434853486348734883489349034913492349334943495349634973498349935003501350235033504350535063507350835093510351135123513351435153516351735183519352035213522352335243525352635273528352935303531353235333534353535363537353835393540354135423543354435453546354735483549355035513552355335543555355635573558355935603561356235633564356535663567356835693570357135723573357435753576357735783579358035813582358335843585358635873588358935903591359235933594359535963597359835993600360136023603360436053606360736083609361036113612361336143615361636173618361936203621362236233624362536263627362836293630363136323633363436353636363736383639364036413642364336443645364636473648364936503651365236533654365536563657365836593660366136623663366436653666366736683669367036713672367336743675367636773678367936803681368236833684368536863687368836893690369136923693369436953696369736983699370037013702370337043705370637073708370937103711371237133714371537163717371837193720372137223723372437253726372737283729373037313732373337343735373637373738373937403741374237433744374537463747374837493750375137523753375437553756375737583759376037613762376337643765376637673768376937703771377237733774377537763777377837793780378137823783378437853786378737883789379037913792379337943795379637973798379938003801380238033804380538063807380838093810381138123813381438153816381738183819382038213822382338243825382638273828382938303831383238333834383538363837383838393840384138423843384438453846384738483849385038513852385338543855385638573858385938603861386238633864386538663867386838693870387138723873387438753876387738783879388038813882388338843885388638873888388938903891389238933894389538963897389838993900390139023903390439053906390739083909391039113912391339143915391639173918391939203921392239233924392539263927392839293930393139323933393439353936393739383939394039413942394339443945394639473948394939503951395239533954395539563957395839593960396139623963396439653966396739683969397039713972397339743975397639773978397939803981398239833984398539863987398839893990399139923993399439953996399739983999400040014002400340044005400640074008400940104011401240134014401540164017401840194020402140224023402440254026402740284029403040314032403340344035403640374038403940404041404240434044404540464047404840494050405140524053405440554056405740584059406040614062406340644065406640674068406940704071407240734074407540764077407840794080408140824083408440854086408740884089409040914092409340944095409640974098409941004101410241034104410541064107410841094110411141124113411441154116411741184119412041214122412341244125412641274128412941304131413241334134413541364137413841394140414141424143414441454146414741484149415041514152415341544155415641574158415941604161416241634164
  1. /**************************************************************************/
  2. /* gdscript_editor.cpp */
  3. /**************************************************************************/
  4. /* This file is part of: */
  5. /* GODOT ENGINE */
  6. /* https://godotengine.org */
  7. /**************************************************************************/
  8. /* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
  9. /* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
  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.h"
  31. #include "gdscript_analyzer.h"
  32. #include "gdscript_compiler.h"
  33. #include "gdscript_parser.h"
  34. #include "gdscript_tokenizer.h"
  35. #include "gdscript_utility_functions.h"
  36. #ifdef TOOLS_ENABLED
  37. #include "editor/script_templates/templates.gen.h"
  38. #endif
  39. #include "core/config/engine.h"
  40. #include "core/core_constants.h"
  41. #include "core/io/file_access.h"
  42. #include "core/math/expression.h"
  43. #ifdef TOOLS_ENABLED
  44. #include "core/config/project_settings.h"
  45. #include "editor/editor_file_system.h"
  46. #include "editor/editor_settings.h"
  47. #endif
  48. void GDScriptLanguage::get_comment_delimiters(List<String> *p_delimiters) const {
  49. p_delimiters->push_back("#");
  50. }
  51. void GDScriptLanguage::get_doc_comment_delimiters(List<String> *p_delimiters) const {
  52. p_delimiters->push_back("##");
  53. }
  54. void GDScriptLanguage::get_string_delimiters(List<String> *p_delimiters) const {
  55. p_delimiters->push_back("\" \"");
  56. p_delimiters->push_back("' '");
  57. p_delimiters->push_back("\"\"\" \"\"\"");
  58. p_delimiters->push_back("''' '''");
  59. // NOTE: StringName, NodePath and r-strings are not listed here.
  60. }
  61. bool GDScriptLanguage::is_using_templates() {
  62. return true;
  63. }
  64. Ref<Script> GDScriptLanguage::make_template(const String &p_template, const String &p_class_name, const String &p_base_class_name) const {
  65. Ref<GDScript> scr;
  66. scr.instantiate();
  67. String processed_template = p_template;
  68. bool type_hints = false;
  69. #ifdef TOOLS_ENABLED
  70. type_hints = EDITOR_GET("text_editor/completion/add_type_hints");
  71. #endif
  72. if (!type_hints) {
  73. processed_template = processed_template.replace(": int", "")
  74. .replace(": Shader.Mode", "")
  75. .replace(": VisualShader.Type", "")
  76. .replace(": float", "")
  77. .replace(": String", "")
  78. .replace(": Array[String]", "")
  79. .replace(": Node", "")
  80. .replace(": CharFXTransform", "")
  81. .replace(":=", "=")
  82. .replace(" -> void", "")
  83. .replace(" -> bool", "")
  84. .replace(" -> int", "")
  85. .replace(" -> PortType", "")
  86. .replace(" -> String", "")
  87. .replace(" -> Object", "");
  88. }
  89. processed_template = processed_template.replace("_BASE_", p_base_class_name)
  90. .replace("_CLASS_SNAKE_CASE_", p_class_name.to_snake_case().validate_unicode_identifier())
  91. .replace("_CLASS_", p_class_name.to_pascal_case().validate_unicode_identifier())
  92. .replace("_TS_", _get_indentation());
  93. scr->set_source_code(processed_template);
  94. return scr;
  95. }
  96. Vector<ScriptLanguage::ScriptTemplate> GDScriptLanguage::get_built_in_templates(const StringName &p_object) {
  97. Vector<ScriptLanguage::ScriptTemplate> templates;
  98. #ifdef TOOLS_ENABLED
  99. for (int i = 0; i < TEMPLATES_ARRAY_SIZE; i++) {
  100. if (TEMPLATES[i].inherit == p_object) {
  101. templates.append(TEMPLATES[i]);
  102. }
  103. }
  104. #endif
  105. return templates;
  106. }
  107. static void get_function_names_recursively(const GDScriptParser::ClassNode *p_class, const String &p_prefix, HashMap<int, String> &r_funcs) {
  108. for (int i = 0; i < p_class->members.size(); i++) {
  109. if (p_class->members[i].type == GDScriptParser::ClassNode::Member::FUNCTION) {
  110. const GDScriptParser::FunctionNode *function = p_class->members[i].function;
  111. r_funcs[function->start_line] = p_prefix.is_empty() ? String(function->identifier->name) : p_prefix + "." + String(function->identifier->name);
  112. } else if (p_class->members[i].type == GDScriptParser::ClassNode::Member::CLASS) {
  113. String new_prefix = p_class->members[i].m_class->identifier->name;
  114. get_function_names_recursively(p_class->members[i].m_class, p_prefix.is_empty() ? new_prefix : p_prefix + "." + new_prefix, r_funcs);
  115. }
  116. }
  117. }
  118. bool GDScriptLanguage::validate(const String &p_script, const String &p_path, List<String> *r_functions, List<ScriptLanguage::ScriptError> *r_errors, List<ScriptLanguage::Warning> *r_warnings, HashSet<int> *r_safe_lines) const {
  119. GDScriptParser parser;
  120. GDScriptAnalyzer analyzer(&parser);
  121. Error err = parser.parse(p_script, p_path, false);
  122. if (err == OK) {
  123. err = analyzer.analyze();
  124. }
  125. #ifdef DEBUG_ENABLED
  126. if (r_warnings) {
  127. for (const GDScriptWarning &E : parser.get_warnings()) {
  128. const GDScriptWarning &warn = E;
  129. ScriptLanguage::Warning w;
  130. w.start_line = warn.start_line;
  131. w.end_line = warn.end_line;
  132. w.leftmost_column = warn.leftmost_column;
  133. w.rightmost_column = warn.rightmost_column;
  134. w.code = (int)warn.code;
  135. w.string_code = GDScriptWarning::get_name_from_code(warn.code);
  136. w.message = warn.get_message();
  137. r_warnings->push_back(w);
  138. }
  139. }
  140. #endif
  141. if (err) {
  142. if (r_errors) {
  143. for (const GDScriptParser::ParserError &pe : parser.get_errors()) {
  144. ScriptLanguage::ScriptError e;
  145. e.path = p_path;
  146. e.line = pe.line;
  147. e.column = pe.column;
  148. e.message = pe.message;
  149. r_errors->push_back(e);
  150. }
  151. for (KeyValue<String, Ref<GDScriptParserRef>> E : parser.get_depended_parsers()) {
  152. GDScriptParser *depended_parser = E.value->get_parser();
  153. for (const GDScriptParser::ParserError &pe : depended_parser->get_errors()) {
  154. ScriptLanguage::ScriptError e;
  155. e.path = E.key;
  156. e.line = pe.line;
  157. e.column = pe.column;
  158. e.message = pe.message;
  159. r_errors->push_back(e);
  160. }
  161. }
  162. }
  163. return false;
  164. } else {
  165. const GDScriptParser::ClassNode *cl = parser.get_tree();
  166. HashMap<int, String> funcs;
  167. get_function_names_recursively(cl, "", funcs);
  168. for (const KeyValue<int, String> &E : funcs) {
  169. r_functions->push_back(E.value + ":" + itos(E.key));
  170. }
  171. }
  172. #ifdef DEBUG_ENABLED
  173. if (r_safe_lines) {
  174. const HashSet<int> &unsafe_lines = parser.get_unsafe_lines();
  175. for (int i = 1; i <= parser.get_last_line_number(); i++) {
  176. if (!unsafe_lines.has(i)) {
  177. r_safe_lines->insert(i);
  178. }
  179. }
  180. }
  181. #endif
  182. return true;
  183. }
  184. bool GDScriptLanguage::supports_builtin_mode() const {
  185. return true;
  186. }
  187. bool GDScriptLanguage::supports_documentation() const {
  188. return true;
  189. }
  190. int GDScriptLanguage::find_function(const String &p_function, const String &p_code) const {
  191. GDScriptTokenizerText tokenizer;
  192. tokenizer.set_source_code(p_code);
  193. int indent = 0;
  194. GDScriptTokenizer::Token current = tokenizer.scan();
  195. while (current.type != GDScriptTokenizer::Token::TK_EOF && current.type != GDScriptTokenizer::Token::ERROR) {
  196. if (current.type == GDScriptTokenizer::Token::INDENT) {
  197. indent++;
  198. } else if (current.type == GDScriptTokenizer::Token::DEDENT) {
  199. indent--;
  200. }
  201. if (indent == 0 && current.type == GDScriptTokenizer::Token::FUNC) {
  202. current = tokenizer.scan();
  203. if (current.is_identifier()) {
  204. String identifier = current.get_identifier();
  205. if (identifier == p_function) {
  206. return current.start_line;
  207. }
  208. }
  209. }
  210. current = tokenizer.scan();
  211. }
  212. return -1;
  213. }
  214. Script *GDScriptLanguage::create_script() const {
  215. return memnew(GDScript);
  216. }
  217. /* DEBUGGER FUNCTIONS */
  218. thread_local int GDScriptLanguage::_debug_parse_err_line = -1;
  219. thread_local String GDScriptLanguage::_debug_parse_err_file;
  220. thread_local String GDScriptLanguage::_debug_error;
  221. bool GDScriptLanguage::debug_break_parse(const String &p_file, int p_line, const String &p_error) {
  222. // break because of parse error
  223. if (EngineDebugger::is_active() && Thread::get_caller_id() == Thread::get_main_id()) {
  224. _debug_parse_err_line = p_line;
  225. _debug_parse_err_file = p_file;
  226. _debug_error = p_error;
  227. EngineDebugger::get_script_debugger()->debug(this, false, true);
  228. // Because this is thread local, clear the memory afterwards.
  229. _debug_parse_err_file = String();
  230. _debug_error = String();
  231. return true;
  232. } else {
  233. return false;
  234. }
  235. }
  236. bool GDScriptLanguage::debug_break(const String &p_error, bool p_allow_continue) {
  237. if (EngineDebugger::is_active()) {
  238. _debug_parse_err_line = -1;
  239. _debug_parse_err_file = "";
  240. _debug_error = p_error;
  241. bool is_error_breakpoint = p_error != "Breakpoint";
  242. EngineDebugger::get_script_debugger()->debug(this, p_allow_continue, is_error_breakpoint);
  243. // Because this is thread local, clear the memory afterwards.
  244. _debug_parse_err_file = String();
  245. _debug_error = String();
  246. return true;
  247. } else {
  248. return false;
  249. }
  250. }
  251. String GDScriptLanguage::debug_get_error() const {
  252. return _debug_error;
  253. }
  254. int GDScriptLanguage::debug_get_stack_level_count() const {
  255. if (_debug_parse_err_line >= 0) {
  256. return 1;
  257. }
  258. return _call_stack.stack_pos;
  259. }
  260. int GDScriptLanguage::debug_get_stack_level_line(int p_level) const {
  261. if (_debug_parse_err_line >= 0) {
  262. return _debug_parse_err_line;
  263. }
  264. ERR_FAIL_INDEX_V(p_level, _call_stack.stack_pos, -1);
  265. int l = _call_stack.stack_pos - p_level - 1;
  266. return *(_call_stack.levels[l].line);
  267. }
  268. String GDScriptLanguage::debug_get_stack_level_function(int p_level) const {
  269. if (_debug_parse_err_line >= 0) {
  270. return "";
  271. }
  272. ERR_FAIL_INDEX_V(p_level, _call_stack.stack_pos, "");
  273. int l = _call_stack.stack_pos - p_level - 1;
  274. return _call_stack.levels[l].function->get_name();
  275. }
  276. String GDScriptLanguage::debug_get_stack_level_source(int p_level) const {
  277. if (_debug_parse_err_line >= 0) {
  278. return _debug_parse_err_file;
  279. }
  280. ERR_FAIL_INDEX_V(p_level, _call_stack.stack_pos, "");
  281. int l = _call_stack.stack_pos - p_level - 1;
  282. return _call_stack.levels[l].function->get_source();
  283. }
  284. void GDScriptLanguage::debug_get_stack_level_locals(int p_level, List<String> *p_locals, List<Variant> *p_values, int p_max_subitems, int p_max_depth) {
  285. if (_debug_parse_err_line >= 0) {
  286. return;
  287. }
  288. ERR_FAIL_INDEX(p_level, _call_stack.stack_pos);
  289. int l = _call_stack.stack_pos - p_level - 1;
  290. GDScriptFunction *f = _call_stack.levels[l].function;
  291. List<Pair<StringName, int>> locals;
  292. f->debug_get_stack_member_state(*_call_stack.levels[l].line, &locals);
  293. for (const Pair<StringName, int> &E : locals) {
  294. p_locals->push_back(E.first);
  295. p_values->push_back(_call_stack.levels[l].stack[E.second]);
  296. }
  297. }
  298. void GDScriptLanguage::debug_get_stack_level_members(int p_level, List<String> *p_members, List<Variant> *p_values, int p_max_subitems, int p_max_depth) {
  299. if (_debug_parse_err_line >= 0) {
  300. return;
  301. }
  302. ERR_FAIL_INDEX(p_level, _call_stack.stack_pos);
  303. int l = _call_stack.stack_pos - p_level - 1;
  304. GDScriptInstance *instance = _call_stack.levels[l].instance;
  305. if (!instance) {
  306. return;
  307. }
  308. Ref<GDScript> scr = instance->get_script();
  309. ERR_FAIL_COND(scr.is_null());
  310. const HashMap<StringName, GDScript::MemberInfo> &mi = scr->debug_get_member_indices();
  311. for (const KeyValue<StringName, GDScript::MemberInfo> &E : mi) {
  312. p_members->push_back(E.key);
  313. p_values->push_back(instance->debug_get_member_by_index(E.value.index));
  314. }
  315. }
  316. ScriptInstance *GDScriptLanguage::debug_get_stack_level_instance(int p_level) {
  317. if (_debug_parse_err_line >= 0) {
  318. return nullptr;
  319. }
  320. ERR_FAIL_INDEX_V(p_level, _call_stack.stack_pos, nullptr);
  321. int l = _call_stack.stack_pos - p_level - 1;
  322. ScriptInstance *instance = _call_stack.levels[l].instance;
  323. return instance;
  324. }
  325. void GDScriptLanguage::debug_get_globals(List<String> *p_globals, List<Variant> *p_values, int p_max_subitems, int p_max_depth) {
  326. const HashMap<StringName, int> &name_idx = GDScriptLanguage::get_singleton()->get_global_map();
  327. const Variant *gl_array = GDScriptLanguage::get_singleton()->get_global_array();
  328. List<Pair<String, Variant>> cinfo;
  329. get_public_constants(&cinfo);
  330. for (const KeyValue<StringName, int> &E : name_idx) {
  331. if (ClassDB::class_exists(E.key) || Engine::get_singleton()->has_singleton(E.key)) {
  332. continue;
  333. }
  334. bool is_script_constant = false;
  335. for (List<Pair<String, Variant>>::Element *CE = cinfo.front(); CE; CE = CE->next()) {
  336. if (CE->get().first == E.key) {
  337. is_script_constant = true;
  338. break;
  339. }
  340. }
  341. if (is_script_constant) {
  342. continue;
  343. }
  344. const Variant &var = gl_array[E.value];
  345. bool freed = false;
  346. const Object *obj = var.get_validated_object_with_check(freed);
  347. if (obj && !freed) {
  348. if (Object::cast_to<GDScriptNativeClass>(obj)) {
  349. continue;
  350. }
  351. }
  352. bool skip = false;
  353. for (int i = 0; i < CoreConstants::get_global_constant_count(); i++) {
  354. if (E.key == CoreConstants::get_global_constant_name(i)) {
  355. skip = true;
  356. break;
  357. }
  358. }
  359. if (skip) {
  360. continue;
  361. }
  362. p_globals->push_back(E.key);
  363. p_values->push_back(var);
  364. }
  365. }
  366. String GDScriptLanguage::debug_parse_stack_level_expression(int p_level, const String &p_expression, int p_max_subitems, int p_max_depth) {
  367. List<String> names;
  368. List<Variant> values;
  369. debug_get_stack_level_locals(p_level, &names, &values, p_max_subitems, p_max_depth);
  370. Vector<String> name_vector;
  371. for (const String &name : names) {
  372. name_vector.push_back(name);
  373. }
  374. Array value_array;
  375. for (const Variant &value : values) {
  376. value_array.push_back(value);
  377. }
  378. Expression expression;
  379. if (expression.parse(p_expression, name_vector) == OK) {
  380. ScriptInstance *instance = debug_get_stack_level_instance(p_level);
  381. if (instance) {
  382. Variant return_val = expression.execute(value_array, instance->get_owner());
  383. return return_val.get_construct_string();
  384. }
  385. }
  386. return String();
  387. }
  388. void GDScriptLanguage::get_recognized_extensions(List<String> *p_extensions) const {
  389. p_extensions->push_back("gd");
  390. }
  391. void GDScriptLanguage::get_public_functions(List<MethodInfo> *p_functions) const {
  392. List<StringName> functions;
  393. GDScriptUtilityFunctions::get_function_list(&functions);
  394. for (const StringName &E : functions) {
  395. p_functions->push_back(GDScriptUtilityFunctions::get_function_info(E));
  396. }
  397. // Not really "functions", but show in documentation.
  398. {
  399. MethodInfo mi;
  400. mi.name = "preload";
  401. mi.arguments.push_back(PropertyInfo(Variant::STRING, "path"));
  402. mi.return_val = PropertyInfo(Variant::OBJECT, "", PROPERTY_HINT_RESOURCE_TYPE, "Resource");
  403. p_functions->push_back(mi);
  404. }
  405. {
  406. MethodInfo mi;
  407. mi.name = "assert";
  408. mi.return_val.type = Variant::NIL;
  409. mi.arguments.push_back(PropertyInfo(Variant::BOOL, "condition"));
  410. mi.arguments.push_back(PropertyInfo(Variant::STRING, "message"));
  411. mi.default_arguments.push_back(String());
  412. p_functions->push_back(mi);
  413. }
  414. }
  415. void GDScriptLanguage::get_public_constants(List<Pair<String, Variant>> *p_constants) const {
  416. Pair<String, Variant> pi;
  417. pi.first = "PI";
  418. pi.second = Math_PI;
  419. p_constants->push_back(pi);
  420. Pair<String, Variant> tau;
  421. tau.first = "TAU";
  422. tau.second = Math_TAU;
  423. p_constants->push_back(tau);
  424. Pair<String, Variant> infinity;
  425. infinity.first = "INF";
  426. infinity.second = INFINITY;
  427. p_constants->push_back(infinity);
  428. Pair<String, Variant> nan;
  429. nan.first = "NAN";
  430. nan.second = NAN;
  431. p_constants->push_back(nan);
  432. }
  433. void GDScriptLanguage::get_public_annotations(List<MethodInfo> *p_annotations) const {
  434. GDScriptParser parser;
  435. List<MethodInfo> annotations;
  436. parser.get_annotation_list(&annotations);
  437. for (const MethodInfo &E : annotations) {
  438. p_annotations->push_back(E);
  439. }
  440. }
  441. String GDScriptLanguage::make_function(const String &p_class, const String &p_name, const PackedStringArray &p_args) const {
  442. #ifdef TOOLS_ENABLED
  443. bool th = EditorSettings::get_singleton()->get_setting("text_editor/completion/add_type_hints");
  444. #else
  445. bool th = false;
  446. #endif
  447. String s = "func " + p_name + "(";
  448. if (p_args.size()) {
  449. for (int i = 0; i < p_args.size(); i++) {
  450. if (i > 0) {
  451. s += ", ";
  452. }
  453. s += p_args[i].get_slice(":", 0);
  454. if (th) {
  455. String type = p_args[i].get_slice(":", 1);
  456. if (!type.is_empty()) {
  457. s += ": " + type;
  458. }
  459. }
  460. }
  461. }
  462. s += String(")") + (th ? " -> void" : "") + ":\n" + _get_indentation() + "pass # Replace with function body.\n";
  463. return s;
  464. }
  465. //////// COMPLETION //////////
  466. #ifdef TOOLS_ENABLED
  467. #define COMPLETION_RECURSION_LIMIT 200
  468. struct GDScriptCompletionIdentifier {
  469. GDScriptParser::DataType type;
  470. String enumeration;
  471. Variant value;
  472. const GDScriptParser::ExpressionNode *assigned_expression = nullptr;
  473. };
  474. // LOCATION METHODS
  475. // These methods are used to populate the `CodeCompletionOption::location` integer.
  476. // For these methods, the location is based on the depth in the inheritance chain that the property
  477. // appears. For example, if you are completing code in a class that inherits Node2D, a property found on Node2D
  478. // will have a "better" (lower) location "score" than a property that is found on CanvasItem.
  479. static int _get_property_location(const StringName &p_class, const StringName &p_property) {
  480. if (!ClassDB::has_property(p_class, p_property)) {
  481. return ScriptLanguage::LOCATION_OTHER;
  482. }
  483. int depth = 0;
  484. StringName class_test = p_class;
  485. while (class_test && !ClassDB::has_property(class_test, p_property, true)) {
  486. class_test = ClassDB::get_parent_class(class_test);
  487. depth++;
  488. }
  489. return depth | ScriptLanguage::LOCATION_PARENT_MASK;
  490. }
  491. static int _get_property_location(Ref<Script> p_script, const StringName &p_property) {
  492. int depth = 0;
  493. Ref<Script> scr = p_script;
  494. while (scr.is_valid()) {
  495. if (scr->get_member_line(p_property) != -1) {
  496. return depth | ScriptLanguage::LOCATION_PARENT_MASK;
  497. }
  498. depth++;
  499. scr = scr->get_base_script();
  500. }
  501. return depth + _get_property_location(p_script->get_instance_base_type(), p_property);
  502. }
  503. static int _get_constant_location(const StringName &p_class, const StringName &p_constant) {
  504. if (!ClassDB::has_integer_constant(p_class, p_constant)) {
  505. return ScriptLanguage::LOCATION_OTHER;
  506. }
  507. int depth = 0;
  508. StringName class_test = p_class;
  509. while (class_test && !ClassDB::has_integer_constant(class_test, p_constant, true)) {
  510. class_test = ClassDB::get_parent_class(class_test);
  511. depth++;
  512. }
  513. return depth | ScriptLanguage::LOCATION_PARENT_MASK;
  514. }
  515. static int _get_constant_location(Ref<Script> p_script, const StringName &p_constant) {
  516. int depth = 0;
  517. Ref<Script> scr = p_script;
  518. while (scr.is_valid()) {
  519. if (scr->get_member_line(p_constant) != -1) {
  520. return depth | ScriptLanguage::LOCATION_PARENT_MASK;
  521. }
  522. depth++;
  523. scr = scr->get_base_script();
  524. }
  525. return depth + _get_constant_location(p_script->get_instance_base_type(), p_constant);
  526. }
  527. static int _get_signal_location(const StringName &p_class, const StringName &p_signal) {
  528. if (!ClassDB::has_signal(p_class, p_signal)) {
  529. return ScriptLanguage::LOCATION_OTHER;
  530. }
  531. int depth = 0;
  532. StringName class_test = p_class;
  533. while (class_test && !ClassDB::has_signal(class_test, p_signal, true)) {
  534. class_test = ClassDB::get_parent_class(class_test);
  535. depth++;
  536. }
  537. return depth | ScriptLanguage::LOCATION_PARENT_MASK;
  538. }
  539. static int _get_signal_location(Ref<Script> p_script, const StringName &p_signal) {
  540. int depth = 0;
  541. Ref<Script> scr = p_script;
  542. while (scr.is_valid()) {
  543. if (scr->get_member_line(p_signal) != -1) {
  544. return depth | ScriptLanguage::LOCATION_PARENT_MASK;
  545. }
  546. depth++;
  547. scr = scr->get_base_script();
  548. }
  549. return depth + _get_signal_location(p_script->get_instance_base_type(), p_signal);
  550. }
  551. static int _get_method_location(const StringName &p_class, const StringName &p_method) {
  552. if (!ClassDB::has_method(p_class, p_method)) {
  553. return ScriptLanguage::LOCATION_OTHER;
  554. }
  555. int depth = 0;
  556. StringName class_test = p_class;
  557. while (class_test && !ClassDB::has_method(class_test, p_method, true)) {
  558. class_test = ClassDB::get_parent_class(class_test);
  559. depth++;
  560. }
  561. return depth | ScriptLanguage::LOCATION_PARENT_MASK;
  562. }
  563. static int _get_enum_constant_location(const StringName &p_class, const StringName &p_enum_constant) {
  564. if (!ClassDB::get_integer_constant_enum(p_class, p_enum_constant)) {
  565. return ScriptLanguage::LOCATION_OTHER;
  566. }
  567. int depth = 0;
  568. StringName class_test = p_class;
  569. while (class_test && !ClassDB::get_integer_constant_enum(class_test, p_enum_constant, true)) {
  570. class_test = ClassDB::get_parent_class(class_test);
  571. depth++;
  572. }
  573. return depth | ScriptLanguage::LOCATION_PARENT_MASK;
  574. }
  575. static int _get_enum_location(const StringName &p_class, const StringName &p_enum) {
  576. if (!ClassDB::has_enum(p_class, p_enum)) {
  577. return ScriptLanguage::LOCATION_OTHER;
  578. }
  579. int depth = 0;
  580. StringName class_test = p_class;
  581. while (class_test && !ClassDB::has_enum(class_test, p_enum, true)) {
  582. class_test = ClassDB::get_parent_class(class_test);
  583. depth++;
  584. }
  585. return depth | ScriptLanguage::LOCATION_PARENT_MASK;
  586. }
  587. // END LOCATION METHODS
  588. static String _trim_parent_class(const String &p_class, const String &p_base_class) {
  589. if (p_base_class.is_empty()) {
  590. return p_class;
  591. }
  592. Vector<String> names = p_class.split(".", false, 1);
  593. if (names.size() == 2) {
  594. const String &first = names[0];
  595. if (ClassDB::class_exists(p_base_class) && ClassDB::class_exists(first) && ClassDB::is_parent_class(p_base_class, first)) {
  596. const String &rest = names[1];
  597. return rest;
  598. }
  599. }
  600. return p_class;
  601. }
  602. static String _get_visual_datatype(const PropertyInfo &p_info, bool p_is_arg, const String &p_base_class = "") {
  603. String class_name = p_info.class_name;
  604. bool is_enum = p_info.type == Variant::INT && p_info.usage & PROPERTY_USAGE_CLASS_IS_ENUM;
  605. // PROPERTY_USAGE_CLASS_IS_BITFIELD: BitField[T] isn't supported (yet?), use plain int.
  606. if ((p_info.type == Variant::OBJECT || is_enum) && !class_name.is_empty()) {
  607. if (is_enum && CoreConstants::is_global_enum(p_info.class_name)) {
  608. return class_name;
  609. }
  610. return _trim_parent_class(class_name, p_base_class);
  611. } else if (p_info.type == Variant::ARRAY && p_info.hint == PROPERTY_HINT_ARRAY_TYPE && !p_info.hint_string.is_empty()) {
  612. return "Array[" + _trim_parent_class(p_info.hint_string, p_base_class) + "]";
  613. } else if (p_info.type == Variant::DICTIONARY && p_info.hint == PROPERTY_HINT_DICTIONARY_TYPE && !p_info.hint_string.is_empty()) {
  614. const String key = p_info.hint_string.get_slice(";", 0);
  615. const String value = p_info.hint_string.get_slice(";", 1);
  616. return "Dictionary[" + _trim_parent_class(key, p_base_class) + ", " + _trim_parent_class(value, p_base_class) + "]";
  617. } else if (p_info.type == Variant::NIL) {
  618. if (p_is_arg || (p_info.usage & PROPERTY_USAGE_NIL_IS_VARIANT)) {
  619. return "Variant";
  620. } else {
  621. return "void";
  622. }
  623. }
  624. return Variant::get_type_name(p_info.type);
  625. }
  626. static String _make_arguments_hint(const MethodInfo &p_info, int p_arg_idx, bool p_is_annotation = false) {
  627. String arghint;
  628. if (!p_is_annotation) {
  629. arghint += _get_visual_datatype(p_info.return_val, false) + " ";
  630. }
  631. arghint += p_info.name + "(";
  632. int def_args = p_info.arguments.size() - p_info.default_arguments.size();
  633. int i = 0;
  634. for (const PropertyInfo &E : p_info.arguments) {
  635. if (i > 0) {
  636. arghint += ", ";
  637. }
  638. if (i == p_arg_idx) {
  639. arghint += String::chr(0xFFFF);
  640. }
  641. arghint += E.name + ": " + _get_visual_datatype(E, true);
  642. if (i - def_args >= 0) {
  643. arghint += String(" = ") + p_info.default_arguments[i - def_args].get_construct_string();
  644. }
  645. if (i == p_arg_idx) {
  646. arghint += String::chr(0xFFFF);
  647. }
  648. i++;
  649. }
  650. if (p_info.flags & METHOD_FLAG_VARARG) {
  651. if (p_info.arguments.size() > 0) {
  652. arghint += ", ";
  653. }
  654. if (p_arg_idx >= p_info.arguments.size()) {
  655. arghint += String::chr(0xFFFF);
  656. }
  657. arghint += "...";
  658. if (p_arg_idx >= p_info.arguments.size()) {
  659. arghint += String::chr(0xFFFF);
  660. }
  661. }
  662. arghint += ")";
  663. return arghint;
  664. }
  665. static String _make_arguments_hint(const GDScriptParser::FunctionNode *p_function, int p_arg_idx, bool p_just_args = false) {
  666. String arghint;
  667. if (p_just_args) {
  668. arghint = "(";
  669. } else {
  670. if (p_function->get_datatype().builtin_type == Variant::NIL) {
  671. arghint = "void " + p_function->identifier->name.operator String() + "(";
  672. } else {
  673. arghint = p_function->get_datatype().to_string() + " " + p_function->identifier->name.operator String() + "(";
  674. }
  675. }
  676. for (int i = 0; i < p_function->parameters.size(); i++) {
  677. if (i > 0) {
  678. arghint += ", ";
  679. }
  680. if (i == p_arg_idx) {
  681. arghint += String::chr(0xFFFF);
  682. }
  683. const GDScriptParser::ParameterNode *par = p_function->parameters[i];
  684. if (!par->get_datatype().is_hard_type()) {
  685. arghint += par->identifier->name.operator String() + ": Variant";
  686. } else {
  687. arghint += par->identifier->name.operator String() + ": " + par->get_datatype().to_string();
  688. }
  689. if (par->initializer) {
  690. String def_val = "<unknown>";
  691. switch (par->initializer->type) {
  692. case GDScriptParser::Node::LITERAL: {
  693. const GDScriptParser::LiteralNode *literal = static_cast<const GDScriptParser::LiteralNode *>(par->initializer);
  694. def_val = literal->value.get_construct_string();
  695. } break;
  696. case GDScriptParser::Node::IDENTIFIER: {
  697. const GDScriptParser::IdentifierNode *id = static_cast<const GDScriptParser::IdentifierNode *>(par->initializer);
  698. def_val = id->name.operator String();
  699. } break;
  700. case GDScriptParser::Node::CALL: {
  701. const GDScriptParser::CallNode *call = static_cast<const GDScriptParser::CallNode *>(par->initializer);
  702. if (call->is_constant && call->reduced) {
  703. def_val = call->reduced_value.get_construct_string();
  704. } else {
  705. def_val = call->function_name.operator String() + (call->arguments.is_empty() ? "()" : "(...)");
  706. }
  707. } break;
  708. case GDScriptParser::Node::ARRAY: {
  709. const GDScriptParser::ArrayNode *arr = static_cast<const GDScriptParser::ArrayNode *>(par->initializer);
  710. if (arr->is_constant && arr->reduced) {
  711. def_val = arr->reduced_value.get_construct_string();
  712. } else {
  713. def_val = arr->elements.is_empty() ? "[]" : "[...]";
  714. }
  715. } break;
  716. case GDScriptParser::Node::DICTIONARY: {
  717. const GDScriptParser::DictionaryNode *dict = static_cast<const GDScriptParser::DictionaryNode *>(par->initializer);
  718. if (dict->is_constant && dict->reduced) {
  719. def_val = dict->reduced_value.get_construct_string();
  720. } else {
  721. def_val = dict->elements.is_empty() ? "{}" : "{...}";
  722. }
  723. } break;
  724. case GDScriptParser::Node::SUBSCRIPT: {
  725. const GDScriptParser::SubscriptNode *sub = static_cast<const GDScriptParser::SubscriptNode *>(par->initializer);
  726. if (sub->is_attribute && sub->datatype.kind == GDScriptParser::DataType::ENUM && !sub->datatype.is_meta_type) {
  727. def_val = sub->get_datatype().to_string() + "." + sub->attribute->name;
  728. } else if (sub->is_constant && sub->reduced) {
  729. def_val = sub->reduced_value.get_construct_string();
  730. }
  731. } break;
  732. default:
  733. break;
  734. }
  735. arghint += " = " + def_val;
  736. }
  737. if (i == p_arg_idx) {
  738. arghint += String::chr(0xFFFF);
  739. }
  740. }
  741. arghint += ")";
  742. return arghint;
  743. }
  744. static void _get_directory_contents(EditorFileSystemDirectory *p_dir, HashMap<String, ScriptLanguage::CodeCompletionOption> &r_list, const StringName &p_required_type = StringName()) {
  745. const String quote_style = EDITOR_GET("text_editor/completion/use_single_quotes") ? "'" : "\"";
  746. const bool requires_type = p_required_type;
  747. for (int i = 0; i < p_dir->get_file_count(); i++) {
  748. if (requires_type && !ClassDB::is_parent_class(p_dir->get_file_type(i), p_required_type)) {
  749. continue;
  750. }
  751. ScriptLanguage::CodeCompletionOption option(p_dir->get_file_path(i), ScriptLanguage::CODE_COMPLETION_KIND_FILE_PATH);
  752. option.insert_text = option.display.quote(quote_style);
  753. r_list.insert(option.display, option);
  754. }
  755. for (int i = 0; i < p_dir->get_subdir_count(); i++) {
  756. _get_directory_contents(p_dir->get_subdir(i), r_list, p_required_type);
  757. }
  758. }
  759. static void _find_annotation_arguments(const GDScriptParser::AnnotationNode *p_annotation, int p_argument, const String p_quote_style, HashMap<String, ScriptLanguage::CodeCompletionOption> &r_result, String &r_arghint) {
  760. r_arghint = _make_arguments_hint(p_annotation->info->info, p_argument, true);
  761. if (p_annotation->name == SNAME("@export_range")) {
  762. if (p_argument == 3 || p_argument == 4 || p_argument == 5) {
  763. // Slider hint.
  764. ScriptLanguage::CodeCompletionOption slider1("or_greater", ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT);
  765. slider1.insert_text = slider1.display.quote(p_quote_style);
  766. r_result.insert(slider1.display, slider1);
  767. ScriptLanguage::CodeCompletionOption slider2("or_less", ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT);
  768. slider2.insert_text = slider2.display.quote(p_quote_style);
  769. r_result.insert(slider2.display, slider2);
  770. ScriptLanguage::CodeCompletionOption slider3("hide_slider", ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT);
  771. slider3.insert_text = slider3.display.quote(p_quote_style);
  772. r_result.insert(slider3.display, slider3);
  773. }
  774. } else if (p_annotation->name == SNAME("@export_exp_easing")) {
  775. if (p_argument == 0 || p_argument == 1) {
  776. // Easing hint.
  777. ScriptLanguage::CodeCompletionOption hint1("attenuation", ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT);
  778. hint1.insert_text = hint1.display.quote(p_quote_style);
  779. r_result.insert(hint1.display, hint1);
  780. ScriptLanguage::CodeCompletionOption hint2("inout", ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT);
  781. hint2.insert_text = hint2.display.quote(p_quote_style);
  782. r_result.insert(hint2.display, hint2);
  783. }
  784. } else if (p_annotation->name == SNAME("@export_node_path")) {
  785. ScriptLanguage::CodeCompletionOption node("Node", ScriptLanguage::CODE_COMPLETION_KIND_CLASS);
  786. node.insert_text = node.display.quote(p_quote_style);
  787. r_result.insert(node.display, node);
  788. List<StringName> native_classes;
  789. ClassDB::get_inheriters_from_class("Node", &native_classes);
  790. for (const StringName &E : native_classes) {
  791. if (!ClassDB::is_class_exposed(E)) {
  792. continue;
  793. }
  794. ScriptLanguage::CodeCompletionOption option(E, ScriptLanguage::CODE_COMPLETION_KIND_CLASS);
  795. option.insert_text = option.display.quote(p_quote_style);
  796. r_result.insert(option.display, option);
  797. }
  798. List<StringName> global_script_classes;
  799. ScriptServer::get_global_class_list(&global_script_classes);
  800. for (const StringName &E : global_script_classes) {
  801. if (!ClassDB::is_parent_class(ScriptServer::get_global_class_native_base(E), "Node")) {
  802. continue;
  803. }
  804. ScriptLanguage::CodeCompletionOption option(E, ScriptLanguage::CODE_COMPLETION_KIND_CLASS);
  805. option.insert_text = option.display.quote(p_quote_style);
  806. r_result.insert(option.display, option);
  807. }
  808. } else if (p_annotation->name == SNAME("@export_custom")) {
  809. switch (p_argument) {
  810. case 0: {
  811. static HashMap<StringName, int64_t> items;
  812. if (unlikely(items.is_empty())) {
  813. CoreConstants::get_enum_values(SNAME("PropertyHint"), &items);
  814. }
  815. for (const KeyValue<StringName, int64_t> &item : items) {
  816. ScriptLanguage::CodeCompletionOption option(item.key, ScriptLanguage::CODE_COMPLETION_KIND_CONSTANT);
  817. r_result.insert(option.display, option);
  818. }
  819. } break;
  820. case 2: {
  821. static HashMap<StringName, int64_t> items;
  822. if (unlikely(items.is_empty())) {
  823. CoreConstants::get_enum_values(SNAME("PropertyUsageFlags"), &items);
  824. }
  825. for (const KeyValue<StringName, int64_t> &item : items) {
  826. ScriptLanguage::CodeCompletionOption option(item.key, ScriptLanguage::CODE_COMPLETION_KIND_CONSTANT);
  827. r_result.insert(option.display, option);
  828. }
  829. } break;
  830. }
  831. } else if (p_annotation->name == SNAME("@warning_ignore")) {
  832. for (int warning_code = 0; warning_code < GDScriptWarning::WARNING_MAX; warning_code++) {
  833. ScriptLanguage::CodeCompletionOption warning(GDScriptWarning::get_name_from_code((GDScriptWarning::Code)warning_code).to_lower(), ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT);
  834. warning.insert_text = warning.display.quote(p_quote_style);
  835. r_result.insert(warning.display, warning);
  836. }
  837. } else if (p_annotation->name == SNAME("@rpc")) {
  838. if (p_argument == 0 || p_argument == 1 || p_argument == 2) {
  839. static const char *options[7] = { "call_local", "call_remote", "any_peer", "authority", "reliable", "unreliable", "unreliable_ordered" };
  840. for (int i = 0; i < 7; i++) {
  841. ScriptLanguage::CodeCompletionOption option(options[i], ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT);
  842. option.insert_text = option.display.quote(p_quote_style);
  843. r_result.insert(option.display, option);
  844. }
  845. }
  846. }
  847. }
  848. static void _find_built_in_variants(HashMap<String, ScriptLanguage::CodeCompletionOption> &r_result, bool exclude_nil = false) {
  849. for (int i = 0; i < Variant::VARIANT_MAX; i++) {
  850. if (!exclude_nil && Variant::Type(i) == Variant::Type::NIL) {
  851. ScriptLanguage::CodeCompletionOption option("null", ScriptLanguage::CODE_COMPLETION_KIND_CLASS);
  852. r_result.insert(option.display, option);
  853. } else {
  854. ScriptLanguage::CodeCompletionOption option(Variant::get_type_name(Variant::Type(i)), ScriptLanguage::CODE_COMPLETION_KIND_CLASS);
  855. r_result.insert(option.display, option);
  856. }
  857. }
  858. }
  859. static void _list_available_types(bool p_inherit_only, GDScriptParser::CompletionContext &p_context, HashMap<String, ScriptLanguage::CodeCompletionOption> &r_result) {
  860. // Built-in Variant Types
  861. _find_built_in_variants(r_result, true);
  862. List<StringName> native_types;
  863. ClassDB::get_class_list(&native_types);
  864. for (const StringName &E : native_types) {
  865. if (ClassDB::is_class_exposed(E) && !Engine::get_singleton()->has_singleton(E)) {
  866. ScriptLanguage::CodeCompletionOption option(E, ScriptLanguage::CODE_COMPLETION_KIND_CLASS);
  867. r_result.insert(option.display, option);
  868. }
  869. }
  870. if (p_context.current_class) {
  871. if (!p_inherit_only && p_context.current_class->base_type.is_set()) {
  872. // Native enums from base class
  873. List<StringName> enums;
  874. ClassDB::get_enum_list(p_context.current_class->base_type.native_type, &enums);
  875. for (const StringName &E : enums) {
  876. ScriptLanguage::CodeCompletionOption option(E, ScriptLanguage::CODE_COMPLETION_KIND_ENUM);
  877. r_result.insert(option.display, option);
  878. }
  879. }
  880. // Check current class for potential types
  881. const GDScriptParser::ClassNode *current = p_context.current_class;
  882. while (current) {
  883. for (int i = 0; i < current->members.size(); i++) {
  884. const GDScriptParser::ClassNode::Member &member = current->members[i];
  885. switch (member.type) {
  886. case GDScriptParser::ClassNode::Member::CLASS: {
  887. ScriptLanguage::CodeCompletionOption option(member.m_class->identifier->name, ScriptLanguage::CODE_COMPLETION_KIND_CLASS, ScriptLanguage::LOCATION_LOCAL);
  888. r_result.insert(option.display, option);
  889. } break;
  890. case GDScriptParser::ClassNode::Member::ENUM: {
  891. if (!p_inherit_only) {
  892. ScriptLanguage::CodeCompletionOption option(member.m_enum->identifier->name, ScriptLanguage::CODE_COMPLETION_KIND_ENUM, ScriptLanguage::LOCATION_LOCAL);
  893. r_result.insert(option.display, option);
  894. }
  895. } break;
  896. case GDScriptParser::ClassNode::Member::CONSTANT: {
  897. if (member.constant->get_datatype().is_meta_type && p_context.current_class->outer != nullptr) {
  898. ScriptLanguage::CodeCompletionOption option(member.constant->identifier->name, ScriptLanguage::CODE_COMPLETION_KIND_CLASS, ScriptLanguage::LOCATION_LOCAL);
  899. r_result.insert(option.display, option);
  900. }
  901. } break;
  902. default:
  903. break;
  904. }
  905. }
  906. current = current->outer;
  907. }
  908. }
  909. // Global scripts
  910. List<StringName> global_classes;
  911. ScriptServer::get_global_class_list(&global_classes);
  912. for (const StringName &E : global_classes) {
  913. ScriptLanguage::CodeCompletionOption option(E, ScriptLanguage::CODE_COMPLETION_KIND_CLASS, ScriptLanguage::LOCATION_OTHER_USER_CODE);
  914. r_result.insert(option.display, option);
  915. }
  916. // Autoload singletons
  917. HashMap<StringName, ProjectSettings::AutoloadInfo> autoloads = ProjectSettings::get_singleton()->get_autoload_list();
  918. for (const KeyValue<StringName, ProjectSettings::AutoloadInfo> &E : autoloads) {
  919. const ProjectSettings::AutoloadInfo &info = E.value;
  920. if (!info.is_singleton || info.path.get_extension().to_lower() != "gd") {
  921. continue;
  922. }
  923. ScriptLanguage::CodeCompletionOption option(info.name, ScriptLanguage::CODE_COMPLETION_KIND_CLASS, ScriptLanguage::LOCATION_OTHER_USER_CODE);
  924. r_result.insert(option.display, option);
  925. }
  926. }
  927. static void _find_identifiers_in_suite(const GDScriptParser::SuiteNode *p_suite, HashMap<String, ScriptLanguage::CodeCompletionOption> &r_result, int p_recursion_depth = 0) {
  928. for (int i = 0; i < p_suite->locals.size(); i++) {
  929. ScriptLanguage::CodeCompletionOption option;
  930. int location = p_recursion_depth == 0 ? ScriptLanguage::LOCATION_LOCAL : (p_recursion_depth | ScriptLanguage::LOCATION_PARENT_MASK);
  931. if (p_suite->locals[i].type == GDScriptParser::SuiteNode::Local::CONSTANT) {
  932. option = ScriptLanguage::CodeCompletionOption(p_suite->locals[i].name, ScriptLanguage::CODE_COMPLETION_KIND_CONSTANT, location);
  933. option.default_value = p_suite->locals[i].constant->initializer->reduced_value;
  934. } else {
  935. option = ScriptLanguage::CodeCompletionOption(p_suite->locals[i].name, ScriptLanguage::CODE_COMPLETION_KIND_VARIABLE, location);
  936. }
  937. r_result.insert(option.display, option);
  938. }
  939. if (p_suite->parent_block) {
  940. _find_identifiers_in_suite(p_suite->parent_block, r_result, p_recursion_depth + 1);
  941. }
  942. }
  943. static void _find_identifiers_in_base(const GDScriptCompletionIdentifier &p_base, bool p_only_functions, bool p_types_only, HashMap<String, ScriptLanguage::CodeCompletionOption> &r_result, int p_recursion_depth);
  944. static void _find_identifiers_in_class(const GDScriptParser::ClassNode *p_class, bool p_only_functions, bool p_types_only, bool p_static, bool p_parent_only, HashMap<String, ScriptLanguage::CodeCompletionOption> &r_result, int p_recursion_depth) {
  945. ERR_FAIL_COND(p_recursion_depth > COMPLETION_RECURSION_LIMIT);
  946. if (!p_parent_only) {
  947. bool outer = false;
  948. const GDScriptParser::ClassNode *clss = p_class;
  949. int classes_processed = 0;
  950. while (clss) {
  951. for (int i = 0; i < clss->members.size(); i++) {
  952. const int location = p_recursion_depth == 0 ? classes_processed : (p_recursion_depth | ScriptLanguage::LOCATION_PARENT_MASK);
  953. const GDScriptParser::ClassNode::Member &member = clss->members[i];
  954. ScriptLanguage::CodeCompletionOption option;
  955. switch (member.type) {
  956. case GDScriptParser::ClassNode::Member::VARIABLE:
  957. if (p_types_only || p_only_functions || outer || (p_static && !member.variable->is_static)) {
  958. continue;
  959. }
  960. option = ScriptLanguage::CodeCompletionOption(member.variable->identifier->name, ScriptLanguage::CODE_COMPLETION_KIND_MEMBER, location);
  961. break;
  962. case GDScriptParser::ClassNode::Member::CONSTANT:
  963. if (p_types_only || p_only_functions) {
  964. continue;
  965. }
  966. if (r_result.has(member.constant->identifier->name)) {
  967. continue;
  968. }
  969. option = ScriptLanguage::CodeCompletionOption(member.constant->identifier->name, ScriptLanguage::CODE_COMPLETION_KIND_CONSTANT, location);
  970. if (member.constant->initializer) {
  971. option.default_value = member.constant->initializer->reduced_value;
  972. }
  973. break;
  974. case GDScriptParser::ClassNode::Member::CLASS:
  975. if (p_only_functions) {
  976. continue;
  977. }
  978. option = ScriptLanguage::CodeCompletionOption(member.m_class->identifier->name, ScriptLanguage::CODE_COMPLETION_KIND_CLASS, location);
  979. break;
  980. case GDScriptParser::ClassNode::Member::ENUM_VALUE:
  981. if (p_types_only || p_only_functions) {
  982. continue;
  983. }
  984. option = ScriptLanguage::CodeCompletionOption(member.enum_value.identifier->name, ScriptLanguage::CODE_COMPLETION_KIND_CONSTANT, location);
  985. break;
  986. case GDScriptParser::ClassNode::Member::ENUM:
  987. if (p_only_functions) {
  988. continue;
  989. }
  990. option = ScriptLanguage::CodeCompletionOption(member.m_enum->identifier->name, ScriptLanguage::CODE_COMPLETION_KIND_ENUM, location);
  991. break;
  992. case GDScriptParser::ClassNode::Member::FUNCTION:
  993. if (p_types_only || outer || (p_static && !member.function->is_static) || member.function->identifier->name.operator String().begins_with("@")) {
  994. continue;
  995. }
  996. option = ScriptLanguage::CodeCompletionOption(member.function->identifier->name, ScriptLanguage::CODE_COMPLETION_KIND_FUNCTION, location);
  997. if (member.function->parameters.size() > 0 || (member.function->info.flags & METHOD_FLAG_VARARG)) {
  998. option.insert_text += "(";
  999. option.display += U"(\u2026)";
  1000. } else {
  1001. option.insert_text += "()";
  1002. option.display += "()";
  1003. }
  1004. break;
  1005. case GDScriptParser::ClassNode::Member::SIGNAL:
  1006. if (p_types_only || p_only_functions || outer || p_static) {
  1007. continue;
  1008. }
  1009. option = ScriptLanguage::CodeCompletionOption(member.signal->identifier->name, ScriptLanguage::CODE_COMPLETION_KIND_SIGNAL, location);
  1010. break;
  1011. case GDScriptParser::ClassNode::Member::GROUP:
  1012. break; // No-op, but silences warnings.
  1013. case GDScriptParser::ClassNode::Member::UNDEFINED:
  1014. break;
  1015. }
  1016. r_result.insert(option.display, option);
  1017. }
  1018. if (p_types_only) {
  1019. break; // Otherwise, it will fill the results with types from the outer class (which is undesired for that case).
  1020. }
  1021. outer = true;
  1022. clss = clss->outer;
  1023. classes_processed++;
  1024. }
  1025. }
  1026. // Parents.
  1027. GDScriptCompletionIdentifier base_type;
  1028. base_type.type = p_class->base_type;
  1029. base_type.type.is_meta_type = p_static;
  1030. _find_identifiers_in_base(base_type, p_only_functions, p_types_only, r_result, p_recursion_depth + 1);
  1031. }
  1032. static void _find_identifiers_in_base(const GDScriptCompletionIdentifier &p_base, bool p_only_functions, bool p_types_only, HashMap<String, ScriptLanguage::CodeCompletionOption> &r_result, int p_recursion_depth) {
  1033. ERR_FAIL_COND(p_recursion_depth > COMPLETION_RECURSION_LIMIT);
  1034. GDScriptParser::DataType base_type = p_base.type;
  1035. if (!p_types_only && base_type.is_meta_type && base_type.kind != GDScriptParser::DataType::BUILTIN && base_type.kind != GDScriptParser::DataType::ENUM) {
  1036. ScriptLanguage::CodeCompletionOption option("new", ScriptLanguage::CODE_COMPLETION_KIND_FUNCTION, ScriptLanguage::LOCATION_LOCAL);
  1037. option.insert_text += "(";
  1038. option.display += U"(\u2026)";
  1039. r_result.insert(option.display, option);
  1040. }
  1041. while (!base_type.has_no_type()) {
  1042. switch (base_type.kind) {
  1043. case GDScriptParser::DataType::CLASS: {
  1044. _find_identifiers_in_class(base_type.class_type, p_only_functions, p_types_only, base_type.is_meta_type, false, r_result, p_recursion_depth);
  1045. // This already finds all parent identifiers, so we are done.
  1046. base_type = GDScriptParser::DataType();
  1047. } break;
  1048. case GDScriptParser::DataType::SCRIPT: {
  1049. Ref<Script> scr = base_type.script_type;
  1050. if (scr.is_valid()) {
  1051. if (p_types_only) {
  1052. // TODO: Need to implement Script::get_script_enum_list and retrieve the enum list from a script.
  1053. } else if (!p_only_functions) {
  1054. if (!base_type.is_meta_type) {
  1055. List<PropertyInfo> members;
  1056. scr->get_script_property_list(&members);
  1057. for (const PropertyInfo &E : members) {
  1058. if (E.usage & (PROPERTY_USAGE_CATEGORY | PROPERTY_USAGE_GROUP | PROPERTY_USAGE_SUBGROUP | PROPERTY_USAGE_INTERNAL)) {
  1059. continue;
  1060. }
  1061. if (E.name.contains("/")) {
  1062. continue;
  1063. }
  1064. int location = p_recursion_depth + _get_property_location(scr, E.name);
  1065. ScriptLanguage::CodeCompletionOption option(E.name, ScriptLanguage::CODE_COMPLETION_KIND_MEMBER, location);
  1066. r_result.insert(option.display, option);
  1067. }
  1068. List<MethodInfo> signals;
  1069. scr->get_script_signal_list(&signals);
  1070. for (const MethodInfo &E : signals) {
  1071. int location = p_recursion_depth + _get_signal_location(scr, E.name);
  1072. ScriptLanguage::CodeCompletionOption option(E.name, ScriptLanguage::CODE_COMPLETION_KIND_SIGNAL, location);
  1073. r_result.insert(option.display, option);
  1074. }
  1075. }
  1076. HashMap<StringName, Variant> constants;
  1077. scr->get_constants(&constants);
  1078. for (const KeyValue<StringName, Variant> &E : constants) {
  1079. int location = p_recursion_depth + _get_constant_location(scr, E.key);
  1080. ScriptLanguage::CodeCompletionOption option(E.key.operator String(), ScriptLanguage::CODE_COMPLETION_KIND_CONSTANT, location);
  1081. r_result.insert(option.display, option);
  1082. }
  1083. }
  1084. if (!p_types_only) {
  1085. List<MethodInfo> methods;
  1086. scr->get_script_method_list(&methods);
  1087. for (const MethodInfo &E : methods) {
  1088. if (E.name.begins_with("@")) {
  1089. continue;
  1090. }
  1091. int location = p_recursion_depth + _get_method_location(scr->get_class_name(), E.name);
  1092. ScriptLanguage::CodeCompletionOption option(E.name, ScriptLanguage::CODE_COMPLETION_KIND_FUNCTION, location);
  1093. if (E.arguments.size() || (E.flags & METHOD_FLAG_VARARG)) {
  1094. option.insert_text += "(";
  1095. option.display += U"(\u2026)";
  1096. } else {
  1097. option.insert_text += "()";
  1098. option.display += "()";
  1099. }
  1100. r_result.insert(option.display, option);
  1101. }
  1102. }
  1103. Ref<Script> base_script = scr->get_base_script();
  1104. if (base_script.is_valid()) {
  1105. base_type.script_type = base_script;
  1106. } else {
  1107. base_type.kind = GDScriptParser::DataType::NATIVE;
  1108. base_type.builtin_type = Variant::OBJECT;
  1109. base_type.native_type = scr->get_instance_base_type();
  1110. }
  1111. } else {
  1112. return;
  1113. }
  1114. } break;
  1115. case GDScriptParser::DataType::NATIVE: {
  1116. StringName type = base_type.native_type;
  1117. if (!ClassDB::class_exists(type)) {
  1118. return;
  1119. }
  1120. List<StringName> enums;
  1121. ClassDB::get_enum_list(type, &enums);
  1122. for (const StringName &E : enums) {
  1123. int location = p_recursion_depth + _get_enum_location(type, E);
  1124. ScriptLanguage::CodeCompletionOption option(E, ScriptLanguage::CODE_COMPLETION_KIND_ENUM, location);
  1125. r_result.insert(option.display, option);
  1126. }
  1127. if (p_types_only) {
  1128. return;
  1129. }
  1130. if (!p_only_functions) {
  1131. List<String> constants;
  1132. ClassDB::get_integer_constant_list(type, &constants);
  1133. for (const String &E : constants) {
  1134. int location = p_recursion_depth + _get_constant_location(type, StringName(E));
  1135. ScriptLanguage::CodeCompletionOption option(E, ScriptLanguage::CODE_COMPLETION_KIND_CONSTANT, location);
  1136. r_result.insert(option.display, option);
  1137. }
  1138. if (!base_type.is_meta_type || Engine::get_singleton()->has_singleton(type)) {
  1139. List<PropertyInfo> pinfo;
  1140. ClassDB::get_property_list(type, &pinfo);
  1141. for (const PropertyInfo &E : pinfo) {
  1142. if (E.usage & (PROPERTY_USAGE_CATEGORY | PROPERTY_USAGE_GROUP | PROPERTY_USAGE_SUBGROUP | PROPERTY_USAGE_INTERNAL)) {
  1143. continue;
  1144. }
  1145. if (E.name.contains("/")) {
  1146. continue;
  1147. }
  1148. int location = p_recursion_depth + _get_property_location(type, E.name);
  1149. ScriptLanguage::CodeCompletionOption option(E.name, ScriptLanguage::CODE_COMPLETION_KIND_MEMBER, location);
  1150. r_result.insert(option.display, option);
  1151. }
  1152. List<MethodInfo> signals;
  1153. ClassDB::get_signal_list(type, &signals);
  1154. for (const MethodInfo &E : signals) {
  1155. int location = p_recursion_depth + _get_signal_location(type, StringName(E.name));
  1156. ScriptLanguage::CodeCompletionOption option(E.name, ScriptLanguage::CODE_COMPLETION_KIND_SIGNAL, location);
  1157. r_result.insert(option.display, option);
  1158. }
  1159. }
  1160. }
  1161. bool only_static = base_type.is_meta_type && !Engine::get_singleton()->has_singleton(type);
  1162. List<MethodInfo> methods;
  1163. ClassDB::get_method_list(type, &methods, false, true);
  1164. for (const MethodInfo &E : methods) {
  1165. if (only_static && (E.flags & METHOD_FLAG_STATIC) == 0) {
  1166. continue;
  1167. }
  1168. if (E.name.begins_with("_")) {
  1169. continue;
  1170. }
  1171. int location = p_recursion_depth + _get_method_location(type, E.name);
  1172. ScriptLanguage::CodeCompletionOption option(E.name, ScriptLanguage::CODE_COMPLETION_KIND_FUNCTION, location);
  1173. if (E.arguments.size() || (E.flags & METHOD_FLAG_VARARG)) {
  1174. option.insert_text += "(";
  1175. option.display += U"(\u2026)";
  1176. } else {
  1177. option.insert_text += "()";
  1178. option.display += "()";
  1179. }
  1180. r_result.insert(option.display, option);
  1181. }
  1182. return;
  1183. } break;
  1184. case GDScriptParser::DataType::ENUM: {
  1185. String type_str = base_type.native_type;
  1186. StringName type = type_str.get_slicec('.', 0);
  1187. StringName type_enum = base_type.enum_type;
  1188. List<StringName> enum_values;
  1189. ClassDB::get_enum_constants(type, type_enum, &enum_values);
  1190. for (const StringName &E : enum_values) {
  1191. int location = p_recursion_depth + _get_enum_constant_location(type, E);
  1192. ScriptLanguage::CodeCompletionOption option(E, ScriptLanguage::CODE_COMPLETION_KIND_CONSTANT, location);
  1193. r_result.insert(option.display, option);
  1194. }
  1195. }
  1196. [[fallthrough]];
  1197. case GDScriptParser::DataType::BUILTIN: {
  1198. if (p_types_only) {
  1199. return;
  1200. }
  1201. Callable::CallError err;
  1202. Variant tmp;
  1203. Variant::construct(base_type.builtin_type, tmp, nullptr, 0, err);
  1204. if (err.error != Callable::CallError::CALL_OK) {
  1205. return;
  1206. }
  1207. int location = ScriptLanguage::LOCATION_OTHER;
  1208. if (!p_only_functions) {
  1209. List<PropertyInfo> members;
  1210. if (p_base.value.get_type() != Variant::NIL) {
  1211. p_base.value.get_property_list(&members);
  1212. } else {
  1213. tmp.get_property_list(&members);
  1214. }
  1215. for (const PropertyInfo &E : members) {
  1216. if (E.usage & (PROPERTY_USAGE_CATEGORY | PROPERTY_USAGE_GROUP | PROPERTY_USAGE_SUBGROUP | PROPERTY_USAGE_INTERNAL)) {
  1217. continue;
  1218. }
  1219. if (!String(E.name).contains("/")) {
  1220. ScriptLanguage::CodeCompletionOption option(E.name, ScriptLanguage::CODE_COMPLETION_KIND_MEMBER, location);
  1221. if (base_type.kind == GDScriptParser::DataType::ENUM) {
  1222. // Sort enum members in their declaration order.
  1223. location += 1;
  1224. }
  1225. if (GDScriptParser::theme_color_names.has(E.name)) {
  1226. option.theme_color_name = GDScriptParser::theme_color_names[E.name];
  1227. }
  1228. r_result.insert(option.display, option);
  1229. }
  1230. }
  1231. }
  1232. List<MethodInfo> methods;
  1233. tmp.get_method_list(&methods);
  1234. for (const MethodInfo &E : methods) {
  1235. if (base_type.kind == GDScriptParser::DataType::ENUM && base_type.is_meta_type && !(E.flags & METHOD_FLAG_CONST)) {
  1236. // Enum types are static and cannot change, therefore we skip non-const dictionary methods.
  1237. continue;
  1238. }
  1239. ScriptLanguage::CodeCompletionOption option(E.name, ScriptLanguage::CODE_COMPLETION_KIND_FUNCTION, location);
  1240. if (E.arguments.size() || (E.flags & METHOD_FLAG_VARARG)) {
  1241. option.insert_text += "(";
  1242. option.display += U"(\u2026)";
  1243. } else {
  1244. option.insert_text += "()";
  1245. option.display += "()";
  1246. }
  1247. r_result.insert(option.display, option);
  1248. }
  1249. return;
  1250. } break;
  1251. default: {
  1252. return;
  1253. } break;
  1254. }
  1255. }
  1256. }
  1257. static void _find_identifiers(const GDScriptParser::CompletionContext &p_context, bool p_only_functions, HashMap<String, ScriptLanguage::CodeCompletionOption> &r_result, int p_recursion_depth) {
  1258. if (!p_only_functions && p_context.current_suite) {
  1259. // This includes function parameters, since they are also locals.
  1260. _find_identifiers_in_suite(p_context.current_suite, r_result);
  1261. }
  1262. if (p_context.current_class) {
  1263. _find_identifiers_in_class(p_context.current_class, p_only_functions, false, (!p_context.current_function || p_context.current_function->is_static), false, r_result, p_recursion_depth);
  1264. }
  1265. List<StringName> functions;
  1266. GDScriptUtilityFunctions::get_function_list(&functions);
  1267. for (const StringName &E : functions) {
  1268. MethodInfo function = GDScriptUtilityFunctions::get_function_info(E);
  1269. ScriptLanguage::CodeCompletionOption option(String(E), ScriptLanguage::CODE_COMPLETION_KIND_FUNCTION);
  1270. if (function.arguments.size() || (function.flags & METHOD_FLAG_VARARG)) {
  1271. option.insert_text += "(";
  1272. option.display += U"(\u2026)";
  1273. } else {
  1274. option.insert_text += "()";
  1275. option.display += "()";
  1276. }
  1277. r_result.insert(option.display, option);
  1278. }
  1279. if (p_only_functions) {
  1280. return;
  1281. }
  1282. _find_built_in_variants(r_result);
  1283. static const char *_keywords[] = {
  1284. "true", "false", "PI", "TAU", "INF", "NAN", "null", "self", "super",
  1285. "break", "breakpoint", "continue", "pass", "return",
  1286. nullptr
  1287. };
  1288. const char **kw = _keywords;
  1289. while (*kw) {
  1290. ScriptLanguage::CodeCompletionOption option(*kw, ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT);
  1291. r_result.insert(option.display, option);
  1292. kw++;
  1293. }
  1294. static const char *_keywords_with_space[] = {
  1295. "and", "not", "or", "in", "as", "class", "class_name", "extends", "is", "func", "signal", "await",
  1296. "const", "enum", "static", "var", "if", "elif", "else", "for", "match", "when", "while",
  1297. nullptr
  1298. };
  1299. const char **kws = _keywords_with_space;
  1300. while (*kws) {
  1301. ScriptLanguage::CodeCompletionOption option(*kws, ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT);
  1302. option.insert_text += " ";
  1303. r_result.insert(option.display, option);
  1304. kws++;
  1305. }
  1306. static const char *_keywords_with_args[] = {
  1307. "assert", "preload",
  1308. nullptr
  1309. };
  1310. const char **kwa = _keywords_with_args;
  1311. while (*kwa) {
  1312. ScriptLanguage::CodeCompletionOption option(*kwa, ScriptLanguage::CODE_COMPLETION_KIND_FUNCTION);
  1313. option.insert_text += "(";
  1314. option.display += U"(\u2026)";
  1315. r_result.insert(option.display, option);
  1316. kwa++;
  1317. }
  1318. List<StringName> utility_func_names;
  1319. Variant::get_utility_function_list(&utility_func_names);
  1320. for (List<StringName>::Element *E = utility_func_names.front(); E; E = E->next()) {
  1321. ScriptLanguage::CodeCompletionOption option(E->get(), ScriptLanguage::CODE_COMPLETION_KIND_FUNCTION);
  1322. option.insert_text += "(";
  1323. option.display += U"(\u2026)"; // As all utility functions contain an argument or more, this is hardcoded here.
  1324. r_result.insert(option.display, option);
  1325. }
  1326. for (const KeyValue<StringName, ProjectSettings::AutoloadInfo> &E : ProjectSettings::get_singleton()->get_autoload_list()) {
  1327. if (!E.value.is_singleton) {
  1328. continue;
  1329. }
  1330. ScriptLanguage::CodeCompletionOption option(E.key, ScriptLanguage::CODE_COMPLETION_KIND_CONSTANT);
  1331. r_result.insert(option.display, option);
  1332. }
  1333. // Native classes and global constants.
  1334. for (const KeyValue<StringName, int> &E : GDScriptLanguage::get_singleton()->get_global_map()) {
  1335. ScriptLanguage::CodeCompletionOption option;
  1336. if (ClassDB::class_exists(E.key) || Engine::get_singleton()->has_singleton(E.key)) {
  1337. option = ScriptLanguage::CodeCompletionOption(E.key.operator String(), ScriptLanguage::CODE_COMPLETION_KIND_CLASS);
  1338. } else {
  1339. option = ScriptLanguage::CodeCompletionOption(E.key.operator String(), ScriptLanguage::CODE_COMPLETION_KIND_CONSTANT);
  1340. }
  1341. r_result.insert(option.display, option);
  1342. }
  1343. // Global classes
  1344. List<StringName> global_classes;
  1345. ScriptServer::get_global_class_list(&global_classes);
  1346. for (const StringName &E : global_classes) {
  1347. ScriptLanguage::CodeCompletionOption option(E, ScriptLanguage::CODE_COMPLETION_KIND_CLASS, ScriptLanguage::LOCATION_OTHER_USER_CODE);
  1348. r_result.insert(option.display, option);
  1349. }
  1350. }
  1351. static GDScriptCompletionIdentifier _type_from_variant(const Variant &p_value, GDScriptParser::CompletionContext &p_context) {
  1352. GDScriptCompletionIdentifier ci;
  1353. ci.value = p_value;
  1354. ci.type.is_constant = true;
  1355. ci.type.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
  1356. ci.type.kind = GDScriptParser::DataType::BUILTIN;
  1357. ci.type.builtin_type = p_value.get_type();
  1358. if (ci.type.builtin_type == Variant::OBJECT) {
  1359. Object *obj = p_value.operator Object *();
  1360. if (!obj) {
  1361. return ci;
  1362. }
  1363. ci.type.native_type = obj->get_class_name();
  1364. Ref<Script> scr = p_value;
  1365. if (scr.is_valid()) {
  1366. ci.type.is_meta_type = true;
  1367. } else {
  1368. ci.type.is_meta_type = false;
  1369. scr = obj->get_script();
  1370. }
  1371. if (scr.is_valid()) {
  1372. ci.type.script_path = scr->get_path();
  1373. ci.type.script_type = scr;
  1374. ci.type.native_type = scr->get_instance_base_type();
  1375. ci.type.kind = GDScriptParser::DataType::SCRIPT;
  1376. if (scr->get_path().ends_with(".gd")) {
  1377. Ref<GDScriptParserRef> parser = p_context.parser->get_depended_parser_for(scr->get_path());
  1378. if (parser.is_valid() && parser->raise_status(GDScriptParserRef::INTERFACE_SOLVED) == OK) {
  1379. ci.type.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
  1380. ci.type.class_type = parser->get_parser()->get_tree();
  1381. ci.type.kind = GDScriptParser::DataType::CLASS;
  1382. return ci;
  1383. }
  1384. }
  1385. } else {
  1386. ci.type.kind = GDScriptParser::DataType::NATIVE;
  1387. }
  1388. }
  1389. return ci;
  1390. }
  1391. static GDScriptCompletionIdentifier _type_from_property(const PropertyInfo &p_property) {
  1392. GDScriptCompletionIdentifier ci;
  1393. if (p_property.type == Variant::NIL) {
  1394. // Variant
  1395. return ci;
  1396. }
  1397. if (p_property.usage & (PROPERTY_USAGE_CLASS_IS_ENUM | PROPERTY_USAGE_CLASS_IS_BITFIELD)) {
  1398. ci.enumeration = p_property.class_name;
  1399. }
  1400. ci.type.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
  1401. ci.type.builtin_type = p_property.type;
  1402. if (p_property.type == Variant::OBJECT) {
  1403. if (ScriptServer::is_global_class(p_property.class_name)) {
  1404. ci.type.kind = GDScriptParser::DataType::SCRIPT;
  1405. ci.type.script_path = ScriptServer::get_global_class_path(p_property.class_name);
  1406. ci.type.native_type = ScriptServer::get_global_class_native_base(p_property.class_name);
  1407. Ref<Script> scr = ResourceLoader::load(ScriptServer::get_global_class_path(p_property.class_name));
  1408. if (scr.is_valid()) {
  1409. ci.type.script_type = scr;
  1410. }
  1411. } else {
  1412. ci.type.kind = GDScriptParser::DataType::NATIVE;
  1413. ci.type.native_type = p_property.class_name == StringName() ? "Object" : p_property.class_name;
  1414. }
  1415. } else {
  1416. ci.type.kind = GDScriptParser::DataType::BUILTIN;
  1417. }
  1418. return ci;
  1419. }
  1420. #define MAX_COMPLETION_RECURSION 100
  1421. struct RecursionCheck {
  1422. int *counter;
  1423. _FORCE_INLINE_ bool check() {
  1424. return (*counter) > MAX_COMPLETION_RECURSION;
  1425. }
  1426. RecursionCheck(int *p_counter) :
  1427. counter(p_counter) {
  1428. (*counter)++;
  1429. }
  1430. ~RecursionCheck() {
  1431. (*counter)--;
  1432. }
  1433. };
  1434. static bool _guess_identifier_type(GDScriptParser::CompletionContext &p_context, const GDScriptParser::IdentifierNode *p_identifier, GDScriptCompletionIdentifier &r_type);
  1435. static bool _guess_identifier_type_from_base(GDScriptParser::CompletionContext &p_context, const GDScriptCompletionIdentifier &p_base, const StringName &p_identifier, GDScriptCompletionIdentifier &r_type);
  1436. static bool _guess_method_return_type_from_base(GDScriptParser::CompletionContext &p_context, const GDScriptCompletionIdentifier &p_base, const StringName &p_method, GDScriptCompletionIdentifier &r_type);
  1437. static bool _is_expression_named_identifier(const GDScriptParser::ExpressionNode *p_expression, const StringName &p_name) {
  1438. if (p_expression) {
  1439. switch (p_expression->type) {
  1440. case GDScriptParser::Node::IDENTIFIER: {
  1441. const GDScriptParser::IdentifierNode *id = static_cast<const GDScriptParser::IdentifierNode *>(p_expression);
  1442. if (id->name == p_name) {
  1443. return true;
  1444. }
  1445. } break;
  1446. case GDScriptParser::Node::CAST: {
  1447. const GDScriptParser::CastNode *cn = static_cast<const GDScriptParser::CastNode *>(p_expression);
  1448. return _is_expression_named_identifier(cn->operand, p_name);
  1449. } break;
  1450. default:
  1451. break;
  1452. }
  1453. }
  1454. return false;
  1455. }
  1456. static bool _guess_expression_type(GDScriptParser::CompletionContext &p_context, const GDScriptParser::ExpressionNode *p_expression, GDScriptCompletionIdentifier &r_type) {
  1457. bool found = false;
  1458. if (p_expression == nullptr) {
  1459. return false;
  1460. }
  1461. static int recursion_depth = 0;
  1462. RecursionCheck recursion(&recursion_depth);
  1463. if (unlikely(recursion.check())) {
  1464. ERR_FAIL_V_MSG(false, "Reached recursion limit while trying to guess type.");
  1465. }
  1466. if (p_expression->is_constant) {
  1467. // Already has a value, so just use that.
  1468. r_type = _type_from_variant(p_expression->reduced_value, p_context);
  1469. switch (p_expression->get_datatype().kind) {
  1470. case GDScriptParser::DataType::ENUM:
  1471. case GDScriptParser::DataType::CLASS:
  1472. r_type.type = p_expression->get_datatype();
  1473. break;
  1474. default:
  1475. break;
  1476. }
  1477. found = true;
  1478. } else {
  1479. switch (p_expression->type) {
  1480. case GDScriptParser::Node::LITERAL: {
  1481. const GDScriptParser::LiteralNode *literal = static_cast<const GDScriptParser::LiteralNode *>(p_expression);
  1482. r_type = _type_from_variant(literal->value, p_context);
  1483. found = true;
  1484. } break;
  1485. case GDScriptParser::Node::SELF: {
  1486. if (p_context.current_class) {
  1487. r_type.type = p_context.current_class->get_datatype();
  1488. r_type.type.is_meta_type = false;
  1489. found = true;
  1490. }
  1491. } break;
  1492. case GDScriptParser::Node::IDENTIFIER: {
  1493. const GDScriptParser::IdentifierNode *id = static_cast<const GDScriptParser::IdentifierNode *>(p_expression);
  1494. found = _guess_identifier_type(p_context, id, r_type);
  1495. } break;
  1496. case GDScriptParser::Node::DICTIONARY: {
  1497. // Try to recreate the dictionary.
  1498. const GDScriptParser::DictionaryNode *dn = static_cast<const GDScriptParser::DictionaryNode *>(p_expression);
  1499. Dictionary d;
  1500. bool full = true;
  1501. for (int i = 0; i < dn->elements.size(); i++) {
  1502. GDScriptCompletionIdentifier key;
  1503. if (_guess_expression_type(p_context, dn->elements[i].key, key)) {
  1504. if (!key.type.is_constant) {
  1505. full = false;
  1506. break;
  1507. }
  1508. GDScriptCompletionIdentifier value;
  1509. if (_guess_expression_type(p_context, dn->elements[i].value, value)) {
  1510. if (!value.type.is_constant) {
  1511. full = false;
  1512. break;
  1513. }
  1514. d[key.value] = value.value;
  1515. } else {
  1516. full = false;
  1517. break;
  1518. }
  1519. } else {
  1520. full = false;
  1521. break;
  1522. }
  1523. }
  1524. if (full) {
  1525. r_type.value = d;
  1526. r_type.type.is_constant = true;
  1527. }
  1528. r_type.type.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
  1529. r_type.type.kind = GDScriptParser::DataType::BUILTIN;
  1530. r_type.type.builtin_type = Variant::DICTIONARY;
  1531. found = true;
  1532. } break;
  1533. case GDScriptParser::Node::ARRAY: {
  1534. // Try to recreate the array
  1535. const GDScriptParser::ArrayNode *an = static_cast<const GDScriptParser::ArrayNode *>(p_expression);
  1536. Array a;
  1537. bool full = true;
  1538. a.resize(an->elements.size());
  1539. for (int i = 0; i < an->elements.size(); i++) {
  1540. GDScriptCompletionIdentifier value;
  1541. if (_guess_expression_type(p_context, an->elements[i], value)) {
  1542. if (value.type.is_constant) {
  1543. a[i] = value.value;
  1544. } else {
  1545. full = false;
  1546. break;
  1547. }
  1548. } else {
  1549. full = false;
  1550. break;
  1551. }
  1552. }
  1553. if (full) {
  1554. // If not fully constant, setting this value is detrimental to the inference.
  1555. r_type.value = a;
  1556. r_type.type.is_constant = true;
  1557. }
  1558. r_type.type.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
  1559. r_type.type.kind = GDScriptParser::DataType::BUILTIN;
  1560. r_type.type.builtin_type = Variant::ARRAY;
  1561. found = true;
  1562. } break;
  1563. case GDScriptParser::Node::CAST: {
  1564. const GDScriptParser::CastNode *cn = static_cast<const GDScriptParser::CastNode *>(p_expression);
  1565. GDScriptCompletionIdentifier value;
  1566. if (_guess_expression_type(p_context, cn->operand, r_type)) {
  1567. r_type.type = cn->get_datatype();
  1568. found = true;
  1569. }
  1570. } break;
  1571. case GDScriptParser::Node::CALL: {
  1572. const GDScriptParser::CallNode *call = static_cast<const GDScriptParser::CallNode *>(p_expression);
  1573. if (GDScriptParser::get_builtin_type(call->function_name) < Variant::VARIANT_MAX) {
  1574. r_type.type.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
  1575. r_type.type.kind = GDScriptParser::DataType::BUILTIN;
  1576. r_type.type.builtin_type = GDScriptParser::get_builtin_type(call->function_name);
  1577. found = true;
  1578. break;
  1579. } else if (GDScriptUtilityFunctions::function_exists(call->function_name)) {
  1580. MethodInfo mi = GDScriptUtilityFunctions::get_function_info(call->function_name);
  1581. r_type = _type_from_property(mi.return_val);
  1582. found = true;
  1583. break;
  1584. } else {
  1585. GDScriptParser::CompletionContext c = p_context;
  1586. c.current_line = call->start_line;
  1587. GDScriptParser::Node::Type callee_type = call->get_callee_type();
  1588. GDScriptCompletionIdentifier base;
  1589. if (callee_type == GDScriptParser::Node::IDENTIFIER || call->is_super) {
  1590. // Simple call, so base is 'self'.
  1591. if (p_context.current_class) {
  1592. if (call->is_super) {
  1593. base.type = p_context.current_class->base_type;
  1594. base.value = p_context.base;
  1595. } else {
  1596. base.type.kind = GDScriptParser::DataType::CLASS;
  1597. base.type.type_source = GDScriptParser::DataType::INFERRED;
  1598. base.type.is_constant = true;
  1599. base.type.class_type = p_context.current_class;
  1600. base.value = p_context.base;
  1601. }
  1602. } else {
  1603. break;
  1604. }
  1605. } else if (callee_type == GDScriptParser::Node::SUBSCRIPT && static_cast<const GDScriptParser::SubscriptNode *>(call->callee)->is_attribute) {
  1606. if (!_guess_expression_type(c, static_cast<const GDScriptParser::SubscriptNode *>(call->callee)->base, base)) {
  1607. found = false;
  1608. break;
  1609. }
  1610. } else {
  1611. break;
  1612. }
  1613. // Try call if constant methods with constant arguments
  1614. if (base.type.is_constant && base.value.get_type() == Variant::OBJECT) {
  1615. GDScriptParser::DataType native_type = base.type;
  1616. while (native_type.kind == GDScriptParser::DataType::CLASS) {
  1617. native_type = native_type.class_type->base_type;
  1618. }
  1619. while (native_type.kind == GDScriptParser::DataType::SCRIPT) {
  1620. if (native_type.script_type.is_valid()) {
  1621. Ref<Script> parent = native_type.script_type->get_base_script();
  1622. if (parent.is_valid()) {
  1623. native_type.script_type = parent;
  1624. } else {
  1625. native_type.kind = GDScriptParser::DataType::NATIVE;
  1626. native_type.builtin_type = Variant::OBJECT;
  1627. native_type.native_type = native_type.script_type->get_instance_base_type();
  1628. if (!ClassDB::class_exists(native_type.native_type)) {
  1629. native_type.kind = GDScriptParser::DataType::UNRESOLVED;
  1630. }
  1631. }
  1632. }
  1633. }
  1634. if (native_type.kind == GDScriptParser::DataType::NATIVE) {
  1635. MethodBind *mb = ClassDB::get_method(native_type.native_type, call->function_name);
  1636. if (mb && mb->is_const()) {
  1637. bool all_is_const = true;
  1638. Vector<Variant> args;
  1639. for (int i = 0; all_is_const && i < call->arguments.size(); i++) {
  1640. GDScriptCompletionIdentifier arg;
  1641. if (!call->arguments[i]->is_constant) {
  1642. all_is_const = false;
  1643. }
  1644. }
  1645. Object *baseptr = base.value;
  1646. if (all_is_const && call->function_name == SNAME("get_node") && ClassDB::is_parent_class(native_type.native_type, SNAME("Node")) && args.size()) {
  1647. String arg1 = args[0];
  1648. if (arg1.begins_with("/root/")) {
  1649. String which = arg1.get_slice("/", 2);
  1650. if (!which.is_empty()) {
  1651. // Try singletons first
  1652. if (GDScriptLanguage::get_singleton()->get_named_globals_map().has(which)) {
  1653. r_type = _type_from_variant(GDScriptLanguage::get_singleton()->get_named_globals_map()[which], p_context);
  1654. found = true;
  1655. } else {
  1656. for (const KeyValue<StringName, ProjectSettings::AutoloadInfo> &E : ProjectSettings::get_singleton()->get_autoload_list()) {
  1657. String name = E.key;
  1658. if (name == which) {
  1659. String script = E.value.path;
  1660. if (!script.begins_with("res://")) {
  1661. script = "res://" + script;
  1662. }
  1663. if (!script.ends_with(".gd")) {
  1664. // not a script, try find the script anyway,
  1665. // may have some success
  1666. script = script.get_basename() + ".gd";
  1667. }
  1668. if (FileAccess::exists(script)) {
  1669. Ref<GDScriptParserRef> parser = p_context.parser->get_depended_parser_for(script);
  1670. if (parser.is_valid() && parser->raise_status(GDScriptParserRef::INTERFACE_SOLVED) == OK) {
  1671. r_type.type.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
  1672. r_type.type.script_path = script;
  1673. r_type.type.class_type = parser->get_parser()->get_tree();
  1674. r_type.type.is_constant = false;
  1675. r_type.type.kind = GDScriptParser::DataType::CLASS;
  1676. r_type.value = Variant();
  1677. found = true;
  1678. }
  1679. }
  1680. break;
  1681. }
  1682. }
  1683. }
  1684. }
  1685. }
  1686. }
  1687. if (!found && all_is_const && baseptr) {
  1688. Vector<const Variant *> argptr;
  1689. for (int i = 0; i < args.size(); i++) {
  1690. argptr.push_back(&args[i]);
  1691. }
  1692. Callable::CallError ce;
  1693. Variant ret = mb->call(baseptr, (const Variant **)argptr.ptr(), argptr.size(), ce);
  1694. if (ce.error == Callable::CallError::CALL_OK && ret.get_type() != Variant::NIL) {
  1695. if (ret.get_type() != Variant::OBJECT || ret.operator Object *() != nullptr) {
  1696. r_type = _type_from_variant(ret, p_context);
  1697. found = true;
  1698. }
  1699. }
  1700. }
  1701. }
  1702. }
  1703. }
  1704. if (!found && base.value.get_type() != Variant::NIL) {
  1705. found = _guess_method_return_type_from_base(c, base, call->function_name, r_type);
  1706. }
  1707. }
  1708. } break;
  1709. case GDScriptParser::Node::SUBSCRIPT: {
  1710. const GDScriptParser::SubscriptNode *subscript = static_cast<const GDScriptParser::SubscriptNode *>(p_expression);
  1711. if (subscript->is_attribute) {
  1712. GDScriptParser::CompletionContext c = p_context;
  1713. c.current_line = subscript->start_line;
  1714. GDScriptCompletionIdentifier base;
  1715. if (!_guess_expression_type(c, subscript->base, base)) {
  1716. found = false;
  1717. break;
  1718. }
  1719. if (base.value.get_type() == Variant::DICTIONARY && base.value.operator Dictionary().has(String(subscript->attribute->name))) {
  1720. Variant value = base.value.operator Dictionary()[String(subscript->attribute->name)];
  1721. r_type = _type_from_variant(value, p_context);
  1722. found = true;
  1723. break;
  1724. }
  1725. const GDScriptParser::DictionaryNode *dn = nullptr;
  1726. if (subscript->base->type == GDScriptParser::Node::DICTIONARY) {
  1727. dn = static_cast<const GDScriptParser::DictionaryNode *>(subscript->base);
  1728. } else if (base.assigned_expression && base.assigned_expression->type == GDScriptParser::Node::DICTIONARY) {
  1729. dn = static_cast<const GDScriptParser::DictionaryNode *>(base.assigned_expression);
  1730. }
  1731. if (dn) {
  1732. for (int i = 0; i < dn->elements.size(); i++) {
  1733. GDScriptCompletionIdentifier key;
  1734. if (!_guess_expression_type(c, dn->elements[i].key, key)) {
  1735. continue;
  1736. }
  1737. if (key.value == String(subscript->attribute->name)) {
  1738. r_type.assigned_expression = dn->elements[i].value;
  1739. found = _guess_expression_type(c, dn->elements[i].value, r_type);
  1740. break;
  1741. }
  1742. }
  1743. }
  1744. if (!found) {
  1745. found = _guess_identifier_type_from_base(c, base, subscript->attribute->name, r_type);
  1746. }
  1747. } else {
  1748. if (subscript->index == nullptr) {
  1749. found = false;
  1750. break;
  1751. }
  1752. GDScriptParser::CompletionContext c = p_context;
  1753. c.current_line = subscript->start_line;
  1754. GDScriptCompletionIdentifier base;
  1755. if (!_guess_expression_type(c, subscript->base, base)) {
  1756. found = false;
  1757. break;
  1758. }
  1759. GDScriptCompletionIdentifier index;
  1760. if (!_guess_expression_type(c, subscript->index, index)) {
  1761. found = false;
  1762. break;
  1763. }
  1764. {
  1765. bool valid;
  1766. Variant value = base.value.get(index.value, &valid);
  1767. if (valid) {
  1768. r_type = _type_from_variant(value, p_context);
  1769. found = true;
  1770. break;
  1771. }
  1772. }
  1773. // Look if it is a dictionary node.
  1774. const GDScriptParser::DictionaryNode *dn = nullptr;
  1775. if (subscript->base->type == GDScriptParser::Node::DICTIONARY) {
  1776. dn = static_cast<const GDScriptParser::DictionaryNode *>(subscript->base);
  1777. } else if (base.assigned_expression && base.assigned_expression->type == GDScriptParser::Node::DICTIONARY) {
  1778. dn = static_cast<const GDScriptParser::DictionaryNode *>(base.assigned_expression);
  1779. }
  1780. if (dn) {
  1781. for (int i = 0; i < dn->elements.size(); i++) {
  1782. GDScriptCompletionIdentifier key;
  1783. if (!_guess_expression_type(c, dn->elements[i].key, key)) {
  1784. continue;
  1785. }
  1786. if (key.value == index.value) {
  1787. r_type.assigned_expression = dn->elements[i].value;
  1788. found = _guess_expression_type(p_context, dn->elements[i].value, r_type);
  1789. break;
  1790. }
  1791. }
  1792. }
  1793. // Look if it is an array node.
  1794. if (!found && index.value.is_num()) {
  1795. int idx = index.value;
  1796. const GDScriptParser::ArrayNode *an = nullptr;
  1797. if (subscript->base->type == GDScriptParser::Node::ARRAY) {
  1798. an = static_cast<const GDScriptParser::ArrayNode *>(subscript->base);
  1799. } else if (base.assigned_expression && base.assigned_expression->type == GDScriptParser::Node::ARRAY) {
  1800. an = static_cast<const GDScriptParser::ArrayNode *>(base.assigned_expression);
  1801. }
  1802. if (an && idx >= 0 && an->elements.size() > idx) {
  1803. r_type.assigned_expression = an->elements[idx];
  1804. found = _guess_expression_type(c, an->elements[idx], r_type);
  1805. break;
  1806. }
  1807. }
  1808. // Look for valid indexing in other types
  1809. if (!found && (index.value.is_string() || index.value.get_type() == Variant::NODE_PATH)) {
  1810. StringName id = index.value;
  1811. found = _guess_identifier_type_from_base(c, base, id, r_type);
  1812. } else if (!found && index.type.kind == GDScriptParser::DataType::BUILTIN) {
  1813. Callable::CallError err;
  1814. Variant base_val;
  1815. Variant::construct(base.type.builtin_type, base_val, nullptr, 0, err);
  1816. bool valid = false;
  1817. Variant res = base_val.get(index.value, &valid);
  1818. if (valid) {
  1819. r_type = _type_from_variant(res, p_context);
  1820. r_type.value = Variant();
  1821. r_type.type.is_constant = false;
  1822. found = true;
  1823. }
  1824. }
  1825. }
  1826. } break;
  1827. case GDScriptParser::Node::BINARY_OPERATOR: {
  1828. const GDScriptParser::BinaryOpNode *op = static_cast<const GDScriptParser::BinaryOpNode *>(p_expression);
  1829. if (op->variant_op == Variant::OP_MAX) {
  1830. break;
  1831. }
  1832. GDScriptParser::CompletionContext context = p_context;
  1833. context.current_line = op->start_line;
  1834. GDScriptCompletionIdentifier p1;
  1835. GDScriptCompletionIdentifier p2;
  1836. if (!_guess_expression_type(context, op->left_operand, p1)) {
  1837. found = false;
  1838. break;
  1839. }
  1840. if (!_guess_expression_type(context, op->right_operand, p2)) {
  1841. found = false;
  1842. break;
  1843. }
  1844. Callable::CallError ce;
  1845. bool v1_use_value = p1.value.get_type() != Variant::NIL && p1.value.get_type() != Variant::OBJECT;
  1846. Variant d1;
  1847. Variant::construct(p1.type.builtin_type, d1, nullptr, 0, ce);
  1848. Variant d2;
  1849. Variant::construct(p2.type.builtin_type, d2, nullptr, 0, ce);
  1850. Variant v1 = (v1_use_value) ? p1.value : d1;
  1851. bool v2_use_value = p2.value.get_type() != Variant::NIL && p2.value.get_type() != Variant::OBJECT;
  1852. Variant v2 = (v2_use_value) ? p2.value : d2;
  1853. // avoid potential invalid ops
  1854. if ((op->variant_op == Variant::OP_DIVIDE || op->variant_op == Variant::OP_MODULE) && v2.get_type() == Variant::INT) {
  1855. v2 = 1;
  1856. v2_use_value = false;
  1857. }
  1858. if (op->variant_op == Variant::OP_DIVIDE && v2.get_type() == Variant::FLOAT) {
  1859. v2 = 1.0;
  1860. v2_use_value = false;
  1861. }
  1862. Variant res;
  1863. bool valid;
  1864. Variant::evaluate(op->variant_op, v1, v2, res, valid);
  1865. if (!valid) {
  1866. found = false;
  1867. break;
  1868. }
  1869. r_type = _type_from_variant(res, p_context);
  1870. if (!v1_use_value || !v2_use_value) {
  1871. r_type.value = Variant();
  1872. r_type.type.is_constant = false;
  1873. }
  1874. found = true;
  1875. } break;
  1876. default:
  1877. break;
  1878. }
  1879. }
  1880. // It may have found a null, but that's never useful
  1881. if (found && r_type.type.kind == GDScriptParser::DataType::BUILTIN && r_type.type.builtin_type == Variant::NIL) {
  1882. found = false;
  1883. }
  1884. // If the found type was not fully analyzed we analyze it now.
  1885. if (found && r_type.type.kind == GDScriptParser::DataType::CLASS && !r_type.type.class_type->resolved_body) {
  1886. Error err;
  1887. Ref<GDScriptParserRef> r = GDScriptCache::get_parser(r_type.type.script_path, GDScriptParserRef::FULLY_SOLVED, err);
  1888. }
  1889. // Check type hint last. For collections we want chance to get the actual value first
  1890. // This way we can detect types from the content of dictionaries and arrays
  1891. if (!found && p_expression->get_datatype().is_hard_type()) {
  1892. r_type.type = p_expression->get_datatype();
  1893. if (!r_type.assigned_expression) {
  1894. r_type.assigned_expression = p_expression;
  1895. }
  1896. found = true;
  1897. }
  1898. return found;
  1899. }
  1900. static bool _guess_identifier_type(GDScriptParser::CompletionContext &p_context, const GDScriptParser::IdentifierNode *p_identifier, GDScriptCompletionIdentifier &r_type) {
  1901. static int recursion_depth = 0;
  1902. RecursionCheck recursion(&recursion_depth);
  1903. if (unlikely(recursion.check())) {
  1904. ERR_FAIL_V_MSG(false, "Reached recursion limit while trying to guess type.");
  1905. }
  1906. // Look in blocks first.
  1907. int last_assign_line = -1;
  1908. const GDScriptParser::ExpressionNode *last_assigned_expression = nullptr;
  1909. GDScriptCompletionIdentifier id_type;
  1910. GDScriptParser::SuiteNode *suite = p_context.current_suite;
  1911. bool is_function_parameter = false;
  1912. bool can_be_local = true;
  1913. switch (p_identifier->source) {
  1914. case GDScriptParser::IdentifierNode::MEMBER_VARIABLE:
  1915. case GDScriptParser::IdentifierNode::MEMBER_CONSTANT:
  1916. case GDScriptParser::IdentifierNode::MEMBER_FUNCTION:
  1917. case GDScriptParser::IdentifierNode::MEMBER_SIGNAL:
  1918. case GDScriptParser::IdentifierNode::MEMBER_CLASS:
  1919. case GDScriptParser::IdentifierNode::INHERITED_VARIABLE:
  1920. case GDScriptParser::IdentifierNode::STATIC_VARIABLE:
  1921. can_be_local = false;
  1922. break;
  1923. default:
  1924. break;
  1925. }
  1926. if (can_be_local && suite && suite->has_local(p_identifier->name)) {
  1927. const GDScriptParser::SuiteNode::Local &local = suite->get_local(p_identifier->name);
  1928. id_type.type = local.get_datatype();
  1929. // Check initializer as the first assignment.
  1930. switch (local.type) {
  1931. case GDScriptParser::SuiteNode::Local::VARIABLE:
  1932. if (local.variable->initializer) {
  1933. last_assign_line = local.variable->initializer->end_line;
  1934. last_assigned_expression = local.variable->initializer;
  1935. }
  1936. break;
  1937. case GDScriptParser::SuiteNode::Local::CONSTANT:
  1938. if (local.constant->initializer) {
  1939. last_assign_line = local.constant->initializer->end_line;
  1940. last_assigned_expression = local.constant->initializer;
  1941. }
  1942. break;
  1943. case GDScriptParser::SuiteNode::Local::PARAMETER:
  1944. if (local.parameter->initializer) {
  1945. last_assign_line = local.parameter->initializer->end_line;
  1946. last_assigned_expression = local.parameter->initializer;
  1947. }
  1948. is_function_parameter = true;
  1949. break;
  1950. default:
  1951. break;
  1952. }
  1953. } else {
  1954. if (p_context.current_class) {
  1955. GDScriptCompletionIdentifier base_identifier;
  1956. GDScriptCompletionIdentifier base;
  1957. base.value = p_context.base;
  1958. base.type.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
  1959. base.type.kind = GDScriptParser::DataType::CLASS;
  1960. base.type.class_type = p_context.current_class;
  1961. base.type.is_meta_type = p_context.current_function && p_context.current_function->is_static;
  1962. if (_guess_identifier_type_from_base(p_context, base, p_identifier->name, base_identifier)) {
  1963. id_type = base_identifier;
  1964. }
  1965. }
  1966. }
  1967. while (suite) {
  1968. for (int i = 0; i < suite->statements.size(); i++) {
  1969. if (suite->statements[i]->end_line >= p_context.current_line) {
  1970. break;
  1971. }
  1972. switch (suite->statements[i]->type) {
  1973. case GDScriptParser::Node::ASSIGNMENT: {
  1974. const GDScriptParser::AssignmentNode *assign = static_cast<const GDScriptParser::AssignmentNode *>(suite->statements[i]);
  1975. if (assign->end_line > last_assign_line && assign->assignee && assign->assigned_value && assign->assignee->type == GDScriptParser::Node::IDENTIFIER) {
  1976. const GDScriptParser::IdentifierNode *id = static_cast<const GDScriptParser::IdentifierNode *>(assign->assignee);
  1977. if (id->name == p_identifier->name && id->source == p_identifier->source) {
  1978. last_assign_line = assign->assigned_value->end_line;
  1979. last_assigned_expression = assign->assigned_value;
  1980. }
  1981. }
  1982. } break;
  1983. default:
  1984. // TODO: Check sub blocks (control flow statements) as they might also reassign stuff.
  1985. break;
  1986. }
  1987. }
  1988. if (suite->parent_if && suite->parent_if->condition && suite->parent_if->condition->type == GDScriptParser::Node::TYPE_TEST) {
  1989. // Operator `is` used, check if identifier is in there! this helps resolve in blocks that are (if (identifier is value)): which are very common..
  1990. // Super dirty hack, but very useful.
  1991. // Credit: Zylann.
  1992. // TODO: this could be hacked to detect ANDed conditions too...
  1993. const GDScriptParser::TypeTestNode *type_test = static_cast<const GDScriptParser::TypeTestNode *>(suite->parent_if->condition);
  1994. if (type_test->operand && type_test->test_type && type_test->operand->type == GDScriptParser::Node::IDENTIFIER && static_cast<const GDScriptParser::IdentifierNode *>(type_test->operand)->name == p_identifier->name && static_cast<const GDScriptParser::IdentifierNode *>(type_test->operand)->source == p_identifier->source) {
  1995. // Bingo.
  1996. GDScriptParser::CompletionContext c = p_context;
  1997. c.current_line = type_test->operand->start_line;
  1998. c.current_suite = suite;
  1999. if (type_test->test_datatype.is_hard_type()) {
  2000. id_type.type = type_test->test_datatype;
  2001. if (last_assign_line < c.current_line) {
  2002. // Override last assignment.
  2003. last_assign_line = c.current_line;
  2004. last_assigned_expression = nullptr;
  2005. }
  2006. }
  2007. }
  2008. }
  2009. suite = suite->parent_block;
  2010. }
  2011. if (last_assigned_expression && last_assign_line < p_context.current_line) {
  2012. GDScriptParser::CompletionContext c = p_context;
  2013. c.current_line = last_assign_line;
  2014. GDScriptCompletionIdentifier assigned_type;
  2015. if (_guess_expression_type(c, last_assigned_expression, assigned_type)) {
  2016. if (id_type.type.is_set() && assigned_type.type.is_set() && !GDScriptAnalyzer::check_type_compatibility(id_type.type, assigned_type.type)) {
  2017. // The assigned type is incompatible. The annotated type takes priority.
  2018. r_type = id_type;
  2019. r_type.assigned_expression = last_assigned_expression;
  2020. } else {
  2021. r_type = assigned_type;
  2022. }
  2023. return true;
  2024. }
  2025. }
  2026. if (is_function_parameter && p_context.current_function && p_context.current_function->source_lambda == nullptr && p_context.current_class) {
  2027. // Check if it's override of native function, then we can assume the type from the signature.
  2028. GDScriptParser::DataType base_type = p_context.current_class->base_type;
  2029. while (base_type.is_set()) {
  2030. switch (base_type.kind) {
  2031. case GDScriptParser::DataType::CLASS:
  2032. if (base_type.class_type->has_function(p_context.current_function->identifier->name)) {
  2033. GDScriptParser::FunctionNode *parent_function = base_type.class_type->get_member(p_context.current_function->identifier->name).function;
  2034. if (parent_function->parameters_indices.has(p_identifier->name)) {
  2035. const GDScriptParser::ParameterNode *parameter = parent_function->parameters[parent_function->parameters_indices[p_identifier->name]];
  2036. if ((!id_type.type.is_set() || id_type.type.is_variant()) && parameter->get_datatype().is_hard_type()) {
  2037. id_type.type = parameter->get_datatype();
  2038. }
  2039. if (parameter->initializer) {
  2040. GDScriptParser::CompletionContext c = p_context;
  2041. c.current_function = parent_function;
  2042. c.current_class = base_type.class_type;
  2043. c.base = nullptr;
  2044. if (_guess_expression_type(c, parameter->initializer, r_type)) {
  2045. return true;
  2046. }
  2047. }
  2048. }
  2049. }
  2050. base_type = base_type.class_type->base_type;
  2051. break;
  2052. case GDScriptParser::DataType::NATIVE: {
  2053. if (id_type.type.is_set() && !id_type.type.is_variant()) {
  2054. base_type = GDScriptParser::DataType();
  2055. break;
  2056. }
  2057. MethodInfo info;
  2058. if (ClassDB::get_method_info(base_type.native_type, p_context.current_function->identifier->name, &info)) {
  2059. for (const PropertyInfo &E : info.arguments) {
  2060. if (E.name == p_identifier->name) {
  2061. r_type = _type_from_property(E);
  2062. return true;
  2063. }
  2064. }
  2065. }
  2066. base_type = GDScriptParser::DataType();
  2067. } break;
  2068. default:
  2069. break;
  2070. }
  2071. }
  2072. }
  2073. if (id_type.type.is_set() && !id_type.type.is_variant()) {
  2074. r_type = id_type;
  2075. return true;
  2076. }
  2077. // Check global scripts.
  2078. if (ScriptServer::is_global_class(p_identifier->name)) {
  2079. String script = ScriptServer::get_global_class_path(p_identifier->name);
  2080. if (script.to_lower().ends_with(".gd")) {
  2081. Ref<GDScriptParserRef> parser = p_context.parser->get_depended_parser_for(script);
  2082. if (parser.is_valid() && parser->raise_status(GDScriptParserRef::INTERFACE_SOLVED) == OK) {
  2083. r_type.type.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
  2084. r_type.type.script_path = script;
  2085. r_type.type.class_type = parser->get_parser()->get_tree();
  2086. r_type.type.is_meta_type = true;
  2087. r_type.type.is_constant = false;
  2088. r_type.type.kind = GDScriptParser::DataType::CLASS;
  2089. r_type.value = Variant();
  2090. return true;
  2091. }
  2092. } else {
  2093. Ref<Script> scr = ResourceLoader::load(ScriptServer::get_global_class_path(p_identifier->name));
  2094. if (scr.is_valid()) {
  2095. r_type = _type_from_variant(scr, p_context);
  2096. r_type.type.is_meta_type = true;
  2097. return true;
  2098. }
  2099. }
  2100. return false;
  2101. }
  2102. // Check global variables (including autoloads).
  2103. if (GDScriptLanguage::get_singleton()->get_named_globals_map().has(p_identifier->name)) {
  2104. r_type = _type_from_variant(GDScriptLanguage::get_singleton()->get_named_globals_map()[p_identifier->name], p_context);
  2105. return true;
  2106. }
  2107. // Check ClassDB.
  2108. if (ClassDB::class_exists(p_identifier->name) && ClassDB::is_class_exposed(p_identifier->name)) {
  2109. r_type.type.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
  2110. r_type.type.kind = GDScriptParser::DataType::NATIVE;
  2111. r_type.type.builtin_type = Variant::OBJECT;
  2112. r_type.type.native_type = p_identifier->name;
  2113. r_type.type.is_constant = true;
  2114. if (Engine::get_singleton()->has_singleton(p_identifier->name)) {
  2115. r_type.type.is_meta_type = false;
  2116. r_type.value = Engine::get_singleton()->get_singleton_object(p_identifier->name);
  2117. } else {
  2118. r_type.type.is_meta_type = true;
  2119. r_type.value = Variant();
  2120. }
  2121. }
  2122. return false;
  2123. }
  2124. static bool _guess_identifier_type_from_base(GDScriptParser::CompletionContext &p_context, const GDScriptCompletionIdentifier &p_base, const StringName &p_identifier, GDScriptCompletionIdentifier &r_type) {
  2125. static int recursion_depth = 0;
  2126. RecursionCheck recursion(&recursion_depth);
  2127. if (unlikely(recursion.check())) {
  2128. ERR_FAIL_V_MSG(false, "Reached recursion limit while trying to guess type.");
  2129. }
  2130. GDScriptParser::DataType base_type = p_base.type;
  2131. bool is_static = base_type.is_meta_type;
  2132. while (base_type.is_set()) {
  2133. switch (base_type.kind) {
  2134. case GDScriptParser::DataType::CLASS:
  2135. if (base_type.class_type->has_member(p_identifier)) {
  2136. const GDScriptParser::ClassNode::Member &member = base_type.class_type->get_member(p_identifier);
  2137. switch (member.type) {
  2138. case GDScriptParser::ClassNode::Member::CONSTANT:
  2139. r_type.type = member.constant->get_datatype();
  2140. if (member.constant->initializer && member.constant->initializer->is_constant) {
  2141. r_type.value = member.constant->initializer->reduced_value;
  2142. }
  2143. return true;
  2144. case GDScriptParser::ClassNode::Member::VARIABLE:
  2145. if (!is_static || member.variable->is_static) {
  2146. if (member.variable->get_datatype().is_set() && !member.variable->get_datatype().is_variant()) {
  2147. r_type.type = member.variable->get_datatype();
  2148. return true;
  2149. } else if (member.variable->initializer) {
  2150. const GDScriptParser::ExpressionNode *init = member.variable->initializer;
  2151. if (init->is_constant) {
  2152. r_type.value = init->reduced_value;
  2153. r_type = _type_from_variant(init->reduced_value, p_context);
  2154. return true;
  2155. } else if (init->start_line == p_context.current_line) {
  2156. return false;
  2157. // Detects if variable is assigned to itself
  2158. } else if (_is_expression_named_identifier(init, member.variable->identifier->name)) {
  2159. if (member.variable->initializer->get_datatype().is_set()) {
  2160. r_type.type = member.variable->initializer->get_datatype();
  2161. } else if (member.variable->get_datatype().is_set() && !member.variable->get_datatype().is_variant()) {
  2162. r_type.type = member.variable->get_datatype();
  2163. }
  2164. return true;
  2165. } else if (_guess_expression_type(p_context, init, r_type)) {
  2166. return true;
  2167. } else if (init->get_datatype().is_set() && !init->get_datatype().is_variant()) {
  2168. r_type.type = init->get_datatype();
  2169. return true;
  2170. }
  2171. }
  2172. }
  2173. // TODO: Check assignments in constructor.
  2174. return false;
  2175. case GDScriptParser::ClassNode::Member::ENUM:
  2176. r_type.type = member.m_enum->get_datatype();
  2177. r_type.enumeration = member.m_enum->identifier->name;
  2178. return true;
  2179. case GDScriptParser::ClassNode::Member::ENUM_VALUE:
  2180. r_type = _type_from_variant(member.enum_value.value, p_context);
  2181. return true;
  2182. case GDScriptParser::ClassNode::Member::SIGNAL:
  2183. r_type.type.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
  2184. r_type.type.kind = GDScriptParser::DataType::BUILTIN;
  2185. r_type.type.builtin_type = Variant::SIGNAL;
  2186. return true;
  2187. case GDScriptParser::ClassNode::Member::FUNCTION:
  2188. if (is_static && !member.function->is_static) {
  2189. return false;
  2190. }
  2191. r_type.type.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
  2192. r_type.type.kind = GDScriptParser::DataType::BUILTIN;
  2193. r_type.type.builtin_type = Variant::CALLABLE;
  2194. return true;
  2195. case GDScriptParser::ClassNode::Member::CLASS:
  2196. r_type.type.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
  2197. r_type.type.kind = GDScriptParser::DataType::CLASS;
  2198. r_type.type.class_type = member.m_class;
  2199. r_type.type.is_meta_type = true;
  2200. return true;
  2201. case GDScriptParser::ClassNode::Member::GROUP:
  2202. return false; // No-op, but silences warnings.
  2203. case GDScriptParser::ClassNode::Member::UNDEFINED:
  2204. return false; // Unreachable.
  2205. }
  2206. return false;
  2207. }
  2208. base_type = base_type.class_type->base_type;
  2209. break;
  2210. case GDScriptParser::DataType::SCRIPT: {
  2211. Ref<Script> scr = base_type.script_type;
  2212. if (scr.is_valid()) {
  2213. HashMap<StringName, Variant> constants;
  2214. scr->get_constants(&constants);
  2215. if (constants.has(p_identifier)) {
  2216. r_type = _type_from_variant(constants[p_identifier], p_context);
  2217. return true;
  2218. }
  2219. List<PropertyInfo> members;
  2220. if (is_static) {
  2221. scr->get_property_list(&members);
  2222. } else {
  2223. scr->get_script_property_list(&members);
  2224. }
  2225. for (const PropertyInfo &prop : members) {
  2226. if (prop.name == p_identifier) {
  2227. r_type = _type_from_property(prop);
  2228. return true;
  2229. }
  2230. }
  2231. Ref<Script> parent = scr->get_base_script();
  2232. if (parent.is_valid()) {
  2233. base_type.script_type = parent;
  2234. } else {
  2235. base_type.kind = GDScriptParser::DataType::NATIVE;
  2236. base_type.builtin_type = Variant::OBJECT;
  2237. base_type.native_type = scr->get_instance_base_type();
  2238. }
  2239. } else {
  2240. return false;
  2241. }
  2242. } break;
  2243. case GDScriptParser::DataType::NATIVE: {
  2244. StringName class_name = base_type.native_type;
  2245. if (!ClassDB::class_exists(class_name)) {
  2246. return false;
  2247. }
  2248. // Skip constants since they're all integers. Type does not matter because int has no members.
  2249. PropertyInfo prop;
  2250. if (ClassDB::get_property_info(class_name, p_identifier, &prop)) {
  2251. StringName getter = ClassDB::get_property_getter(class_name, p_identifier);
  2252. if (getter != StringName()) {
  2253. MethodBind *g = ClassDB::get_method(class_name, getter);
  2254. if (g) {
  2255. r_type = _type_from_property(g->get_return_info());
  2256. return true;
  2257. }
  2258. } else {
  2259. r_type = _type_from_property(prop);
  2260. return true;
  2261. }
  2262. }
  2263. return false;
  2264. } break;
  2265. case GDScriptParser::DataType::BUILTIN: {
  2266. Callable::CallError err;
  2267. Variant tmp;
  2268. Variant::construct(base_type.builtin_type, tmp, nullptr, 0, err);
  2269. if (err.error != Callable::CallError::CALL_OK) {
  2270. return false;
  2271. }
  2272. bool valid = false;
  2273. Variant res = tmp.get(p_identifier, &valid);
  2274. if (valid) {
  2275. r_type = _type_from_variant(res, p_context);
  2276. r_type.value = Variant();
  2277. r_type.type.is_constant = false;
  2278. return true;
  2279. }
  2280. return false;
  2281. } break;
  2282. default: {
  2283. return false;
  2284. } break;
  2285. }
  2286. }
  2287. return false;
  2288. }
  2289. static void _find_last_return_in_block(GDScriptParser::CompletionContext &p_context, int &r_last_return_line, const GDScriptParser::ExpressionNode **r_last_returned_value) {
  2290. if (!p_context.current_suite) {
  2291. return;
  2292. }
  2293. for (int i = 0; i < p_context.current_suite->statements.size(); i++) {
  2294. if (p_context.current_suite->statements[i]->start_line < r_last_return_line) {
  2295. break;
  2296. }
  2297. GDScriptParser::CompletionContext c = p_context;
  2298. switch (p_context.current_suite->statements[i]->type) {
  2299. case GDScriptParser::Node::FOR:
  2300. c.current_suite = static_cast<const GDScriptParser::ForNode *>(p_context.current_suite->statements[i])->loop;
  2301. _find_last_return_in_block(c, r_last_return_line, r_last_returned_value);
  2302. break;
  2303. case GDScriptParser::Node::WHILE:
  2304. c.current_suite = static_cast<const GDScriptParser::WhileNode *>(p_context.current_suite->statements[i])->loop;
  2305. _find_last_return_in_block(c, r_last_return_line, r_last_returned_value);
  2306. break;
  2307. case GDScriptParser::Node::IF: {
  2308. const GDScriptParser::IfNode *_if = static_cast<const GDScriptParser::IfNode *>(p_context.current_suite->statements[i]);
  2309. c.current_suite = _if->true_block;
  2310. _find_last_return_in_block(c, r_last_return_line, r_last_returned_value);
  2311. if (_if->false_block) {
  2312. c.current_suite = _if->false_block;
  2313. _find_last_return_in_block(c, r_last_return_line, r_last_returned_value);
  2314. }
  2315. } break;
  2316. case GDScriptParser::Node::MATCH: {
  2317. const GDScriptParser::MatchNode *match = static_cast<const GDScriptParser::MatchNode *>(p_context.current_suite->statements[i]);
  2318. for (int j = 0; j < match->branches.size(); j++) {
  2319. c.current_suite = match->branches[j]->block;
  2320. _find_last_return_in_block(c, r_last_return_line, r_last_returned_value);
  2321. }
  2322. } break;
  2323. case GDScriptParser::Node::RETURN: {
  2324. const GDScriptParser::ReturnNode *ret = static_cast<const GDScriptParser::ReturnNode *>(p_context.current_suite->statements[i]);
  2325. if (ret->return_value) {
  2326. if (ret->start_line > r_last_return_line) {
  2327. r_last_return_line = ret->start_line;
  2328. *r_last_returned_value = ret->return_value;
  2329. }
  2330. }
  2331. } break;
  2332. default:
  2333. break;
  2334. }
  2335. }
  2336. }
  2337. static bool _guess_method_return_type_from_base(GDScriptParser::CompletionContext &p_context, const GDScriptCompletionIdentifier &p_base, const StringName &p_method, GDScriptCompletionIdentifier &r_type) {
  2338. static int recursion_depth = 0;
  2339. RecursionCheck recursion(&recursion_depth);
  2340. if (unlikely(recursion.check())) {
  2341. ERR_FAIL_V_MSG(false, "Reached recursion limit while trying to guess type.");
  2342. }
  2343. GDScriptParser::DataType base_type = p_base.type;
  2344. bool is_static = base_type.is_meta_type;
  2345. if (is_static && p_method == SNAME("new")) {
  2346. r_type.type = base_type;
  2347. r_type.type.is_meta_type = false;
  2348. r_type.type.is_constant = false;
  2349. return true;
  2350. }
  2351. while (base_type.is_set() && !base_type.is_variant()) {
  2352. switch (base_type.kind) {
  2353. case GDScriptParser::DataType::CLASS:
  2354. if (base_type.class_type->has_function(p_method)) {
  2355. const GDScriptParser::FunctionNode *method = base_type.class_type->get_member(p_method).function;
  2356. if (!is_static || method->is_static) {
  2357. if (method->get_datatype().is_set() && !method->get_datatype().is_variant()) {
  2358. r_type.type = method->get_datatype();
  2359. return true;
  2360. }
  2361. int last_return_line = -1;
  2362. const GDScriptParser::ExpressionNode *last_returned_value = nullptr;
  2363. GDScriptParser::CompletionContext c = p_context;
  2364. c.current_class = base_type.class_type;
  2365. c.current_function = const_cast<GDScriptParser::FunctionNode *>(method);
  2366. c.current_suite = method->body;
  2367. _find_last_return_in_block(c, last_return_line, &last_returned_value);
  2368. if (last_returned_value) {
  2369. c.current_line = c.current_suite->end_line;
  2370. if (_guess_expression_type(c, last_returned_value, r_type)) {
  2371. return true;
  2372. }
  2373. }
  2374. }
  2375. }
  2376. base_type = base_type.class_type->base_type;
  2377. break;
  2378. case GDScriptParser::DataType::SCRIPT: {
  2379. Ref<Script> scr = base_type.script_type;
  2380. if (scr.is_valid()) {
  2381. List<MethodInfo> methods;
  2382. scr->get_script_method_list(&methods);
  2383. for (const MethodInfo &mi : methods) {
  2384. if (mi.name == p_method) {
  2385. r_type = _type_from_property(mi.return_val);
  2386. return true;
  2387. }
  2388. }
  2389. Ref<Script> base_script = scr->get_base_script();
  2390. if (base_script.is_valid()) {
  2391. base_type.script_type = base_script;
  2392. } else {
  2393. base_type.kind = GDScriptParser::DataType::NATIVE;
  2394. base_type.builtin_type = Variant::OBJECT;
  2395. base_type.native_type = scr->get_instance_base_type();
  2396. }
  2397. } else {
  2398. return false;
  2399. }
  2400. } break;
  2401. case GDScriptParser::DataType::NATIVE: {
  2402. if (!ClassDB::class_exists(base_type.native_type)) {
  2403. return false;
  2404. }
  2405. MethodBind *mb = ClassDB::get_method(base_type.native_type, p_method);
  2406. if (mb) {
  2407. r_type = _type_from_property(mb->get_return_info());
  2408. return true;
  2409. }
  2410. return false;
  2411. } break;
  2412. case GDScriptParser::DataType::BUILTIN: {
  2413. Callable::CallError err;
  2414. Variant tmp;
  2415. Variant::construct(base_type.builtin_type, tmp, nullptr, 0, err);
  2416. if (err.error != Callable::CallError::CALL_OK) {
  2417. return false;
  2418. }
  2419. List<MethodInfo> methods;
  2420. tmp.get_method_list(&methods);
  2421. for (const MethodInfo &mi : methods) {
  2422. if (mi.name == p_method) {
  2423. r_type = _type_from_property(mi.return_val);
  2424. return true;
  2425. }
  2426. }
  2427. return false;
  2428. } break;
  2429. default: {
  2430. return false;
  2431. }
  2432. }
  2433. }
  2434. return false;
  2435. }
  2436. static void _find_enumeration_candidates(GDScriptParser::CompletionContext &p_context, const String &p_enum_hint, HashMap<String, ScriptLanguage::CodeCompletionOption> &r_result) {
  2437. if (!p_enum_hint.contains(".")) {
  2438. // Global constant or in the current class.
  2439. StringName current_enum = p_enum_hint;
  2440. if (p_context.current_class && p_context.current_class->has_member(current_enum) && p_context.current_class->get_member(current_enum).type == GDScriptParser::ClassNode::Member::ENUM) {
  2441. const GDScriptParser::EnumNode *_enum = p_context.current_class->get_member(current_enum).m_enum;
  2442. for (int i = 0; i < _enum->values.size(); i++) {
  2443. ScriptLanguage::CodeCompletionOption option(_enum->values[i].identifier->name, ScriptLanguage::CODE_COMPLETION_KIND_ENUM);
  2444. r_result.insert(option.display, option);
  2445. }
  2446. } else {
  2447. for (int i = 0; i < CoreConstants::get_global_constant_count(); i++) {
  2448. if (CoreConstants::get_global_constant_enum(i) == current_enum) {
  2449. ScriptLanguage::CodeCompletionOption option(CoreConstants::get_global_constant_name(i), ScriptLanguage::CODE_COMPLETION_KIND_ENUM);
  2450. r_result.insert(option.display, option);
  2451. }
  2452. }
  2453. }
  2454. } else {
  2455. String class_name = p_enum_hint.get_slice(".", 0);
  2456. String enum_name = p_enum_hint.get_slice(".", 1);
  2457. if (!ClassDB::class_exists(class_name)) {
  2458. return;
  2459. }
  2460. List<StringName> enum_constants;
  2461. ClassDB::get_enum_constants(class_name, enum_name, &enum_constants);
  2462. for (const StringName &E : enum_constants) {
  2463. String candidate = class_name + "." + E;
  2464. int location = _get_enum_constant_location(class_name, E);
  2465. ScriptLanguage::CodeCompletionOption option(candidate, ScriptLanguage::CODE_COMPLETION_KIND_ENUM, location);
  2466. r_result.insert(option.display, option);
  2467. }
  2468. }
  2469. }
  2470. static void _find_call_arguments(GDScriptParser::CompletionContext &p_context, const GDScriptCompletionIdentifier &p_base, const StringName &p_method, int p_argidx, bool p_static, HashMap<String, ScriptLanguage::CodeCompletionOption> &r_result, String &r_arghint) {
  2471. Variant base = p_base.value;
  2472. GDScriptParser::DataType base_type = p_base.type;
  2473. const String quote_style = EDITOR_GET("text_editor/completion/use_single_quotes") ? "'" : "\"";
  2474. const bool use_string_names = EDITOR_GET("text_editor/completion/add_string_name_literals");
  2475. const bool use_node_paths = EDITOR_GET("text_editor/completion/add_node_path_literals");
  2476. while (base_type.is_set() && !base_type.is_variant()) {
  2477. switch (base_type.kind) {
  2478. case GDScriptParser::DataType::CLASS: {
  2479. if (base_type.is_meta_type && p_method == SNAME("new")) {
  2480. const GDScriptParser::ClassNode *current = base_type.class_type;
  2481. do {
  2482. if (current->has_member("_init")) {
  2483. const GDScriptParser::ClassNode::Member &member = current->get_member("_init");
  2484. if (member.type == GDScriptParser::ClassNode::Member::FUNCTION) {
  2485. r_arghint = base_type.class_type->get_datatype().to_string() + " new" + _make_arguments_hint(member.function, p_argidx, true);
  2486. return;
  2487. }
  2488. }
  2489. current = current->base_type.class_type;
  2490. } while (current != nullptr);
  2491. r_arghint = base_type.class_type->get_datatype().to_string() + " new()";
  2492. return;
  2493. }
  2494. if (base_type.class_type->has_member(p_method)) {
  2495. const GDScriptParser::ClassNode::Member &member = base_type.class_type->get_member(p_method);
  2496. if (member.type == GDScriptParser::ClassNode::Member::FUNCTION) {
  2497. r_arghint = _make_arguments_hint(member.function, p_argidx);
  2498. return;
  2499. }
  2500. }
  2501. base_type = base_type.class_type->base_type;
  2502. } break;
  2503. case GDScriptParser::DataType::SCRIPT: {
  2504. if (base_type.script_type->is_valid() && base_type.script_type->has_method(p_method)) {
  2505. r_arghint = _make_arguments_hint(base_type.script_type->get_method_info(p_method), p_argidx);
  2506. return;
  2507. }
  2508. Ref<Script> base_script = base_type.script_type->get_base_script();
  2509. if (base_script.is_valid()) {
  2510. base_type.script_type = base_script;
  2511. } else {
  2512. base_type.kind = GDScriptParser::DataType::NATIVE;
  2513. base_type.builtin_type = Variant::OBJECT;
  2514. base_type.native_type = base_type.script_type->get_instance_base_type();
  2515. }
  2516. } break;
  2517. case GDScriptParser::DataType::NATIVE: {
  2518. StringName class_name = base_type.native_type;
  2519. if (!ClassDB::class_exists(class_name)) {
  2520. base_type.kind = GDScriptParser::DataType::UNRESOLVED;
  2521. break;
  2522. }
  2523. MethodInfo info;
  2524. int method_args = 0;
  2525. if (ClassDB::get_method_info(class_name, p_method, &info)) {
  2526. method_args = info.arguments.size();
  2527. if (base.get_type() == Variant::OBJECT) {
  2528. Object *obj = base.operator Object *();
  2529. if (obj) {
  2530. List<String> options;
  2531. obj->get_argument_options(p_method, p_argidx, &options);
  2532. for (String &opt : options) {
  2533. // Handle user preference.
  2534. if (opt.is_quoted()) {
  2535. opt = opt.unquote().quote(quote_style);
  2536. if (use_string_names && info.arguments.get(p_argidx).type == Variant::STRING_NAME) {
  2537. opt = "&" + opt;
  2538. } else if (use_node_paths && info.arguments.get(p_argidx).type == Variant::NODE_PATH) {
  2539. opt = "^" + opt;
  2540. }
  2541. }
  2542. ScriptLanguage::CodeCompletionOption option(opt, ScriptLanguage::CODE_COMPLETION_KIND_FUNCTION);
  2543. r_result.insert(option.display, option);
  2544. }
  2545. }
  2546. }
  2547. if (p_argidx < method_args) {
  2548. const PropertyInfo &arg_info = info.arguments.get(p_argidx);
  2549. if (arg_info.usage & (PROPERTY_USAGE_CLASS_IS_ENUM | PROPERTY_USAGE_CLASS_IS_BITFIELD)) {
  2550. _find_enumeration_candidates(p_context, arg_info.class_name, r_result);
  2551. }
  2552. }
  2553. r_arghint = _make_arguments_hint(info, p_argidx);
  2554. }
  2555. if (p_argidx == 1 && p_context.node && p_context.node->type == GDScriptParser::Node::CALL && ClassDB::is_parent_class(class_name, SNAME("Tween")) && p_method == SNAME("tween_property")) {
  2556. // Get tweened objects properties.
  2557. GDScriptParser::ExpressionNode *tweened_object = static_cast<GDScriptParser::CallNode *>(p_context.node)->arguments[0];
  2558. StringName native_type = tweened_object->datatype.native_type;
  2559. switch (tweened_object->datatype.kind) {
  2560. case GDScriptParser::DataType::SCRIPT: {
  2561. Ref<Script> script = tweened_object->datatype.script_type;
  2562. native_type = script->get_instance_base_type();
  2563. int n = 0;
  2564. while (script.is_valid()) {
  2565. List<PropertyInfo> properties;
  2566. script->get_script_property_list(&properties);
  2567. for (const PropertyInfo &E : properties) {
  2568. if (E.usage & (PROPERTY_USAGE_SUBGROUP | PROPERTY_USAGE_GROUP | PROPERTY_USAGE_CATEGORY | PROPERTY_USAGE_INTERNAL)) {
  2569. continue;
  2570. }
  2571. String name = E.name.quote(quote_style);
  2572. if (use_node_paths) {
  2573. name = "^" + name;
  2574. }
  2575. ScriptLanguage::CodeCompletionOption option(name, ScriptLanguage::CODE_COMPLETION_KIND_MEMBER, ScriptLanguage::CodeCompletionLocation::LOCATION_LOCAL + n);
  2576. r_result.insert(option.display, option);
  2577. }
  2578. script = script->get_base_script();
  2579. n++;
  2580. }
  2581. } break;
  2582. case GDScriptParser::DataType::CLASS: {
  2583. GDScriptParser::ClassNode *clss = tweened_object->datatype.class_type;
  2584. native_type = clss->base_type.native_type;
  2585. int n = 0;
  2586. while (clss) {
  2587. for (GDScriptParser::ClassNode::Member member : clss->members) {
  2588. if (member.type == GDScriptParser::ClassNode::Member::VARIABLE) {
  2589. String name = member.get_name().quote(quote_style);
  2590. if (use_node_paths) {
  2591. name = "^" + name;
  2592. }
  2593. ScriptLanguage::CodeCompletionOption option(name, ScriptLanguage::CODE_COMPLETION_KIND_MEMBER, ScriptLanguage::CodeCompletionLocation::LOCATION_LOCAL + n);
  2594. r_result.insert(option.display, option);
  2595. }
  2596. }
  2597. if (clss->base_type.kind == GDScriptParser::DataType::Kind::CLASS) {
  2598. clss = clss->base_type.class_type;
  2599. n++;
  2600. } else {
  2601. native_type = clss->base_type.native_type;
  2602. clss = nullptr;
  2603. }
  2604. }
  2605. } break;
  2606. default:
  2607. break;
  2608. }
  2609. List<PropertyInfo> properties;
  2610. ClassDB::get_property_list(native_type, &properties);
  2611. for (const PropertyInfo &E : properties) {
  2612. if (E.usage & (PROPERTY_USAGE_SUBGROUP | PROPERTY_USAGE_GROUP | PROPERTY_USAGE_CATEGORY | PROPERTY_USAGE_INTERNAL)) {
  2613. continue;
  2614. }
  2615. String name = E.name.quote(quote_style);
  2616. if (use_node_paths) {
  2617. name = "^" + name;
  2618. }
  2619. ScriptLanguage::CodeCompletionOption option(name, ScriptLanguage::CODE_COMPLETION_KIND_MEMBER);
  2620. r_result.insert(option.display, option);
  2621. }
  2622. }
  2623. if (p_argidx == 0 && ClassDB::is_parent_class(class_name, SNAME("Node")) && (p_method == SNAME("get_node") || p_method == SNAME("has_node"))) {
  2624. // Get autoloads
  2625. List<PropertyInfo> props;
  2626. ProjectSettings::get_singleton()->get_property_list(&props);
  2627. for (const PropertyInfo &E : props) {
  2628. String s = E.name;
  2629. if (!s.begins_with("autoload/")) {
  2630. continue;
  2631. }
  2632. String name = s.get_slice("/", 1);
  2633. String path = ("/root/" + name).quote(quote_style);
  2634. if (use_node_paths) {
  2635. path = "^" + path;
  2636. }
  2637. ScriptLanguage::CodeCompletionOption option(path, ScriptLanguage::CODE_COMPLETION_KIND_NODE_PATH);
  2638. r_result.insert(option.display, option);
  2639. }
  2640. }
  2641. if (p_argidx == 0 && method_args > 0 && ClassDB::is_parent_class(class_name, SNAME("InputEvent")) && p_method.operator String().contains("action")) {
  2642. // Get input actions
  2643. List<PropertyInfo> props;
  2644. ProjectSettings::get_singleton()->get_property_list(&props);
  2645. for (const PropertyInfo &E : props) {
  2646. String s = E.name;
  2647. if (!s.begins_with("input/")) {
  2648. continue;
  2649. }
  2650. String name = s.get_slice("/", 1).quote(quote_style);
  2651. if (use_string_names) {
  2652. name = "&" + name;
  2653. }
  2654. ScriptLanguage::CodeCompletionOption option(name, ScriptLanguage::CODE_COMPLETION_KIND_CONSTANT);
  2655. r_result.insert(option.display, option);
  2656. }
  2657. }
  2658. if (EDITOR_GET("text_editor/completion/complete_file_paths")) {
  2659. if (p_argidx == 0 && p_method == SNAME("change_scene_to_file") && ClassDB::is_parent_class(class_name, SNAME("SceneTree"))) {
  2660. HashMap<String, ScriptLanguage::CodeCompletionOption> list;
  2661. _get_directory_contents(EditorFileSystem::get_singleton()->get_filesystem(), list, SNAME("PackedScene"));
  2662. for (const KeyValue<String, ScriptLanguage::CodeCompletionOption> &key_value_pair : list) {
  2663. ScriptLanguage::CodeCompletionOption option = key_value_pair.value;
  2664. r_result.insert(option.display, option);
  2665. }
  2666. }
  2667. }
  2668. base_type.kind = GDScriptParser::DataType::UNRESOLVED;
  2669. } break;
  2670. case GDScriptParser::DataType::BUILTIN: {
  2671. if (base.get_type() == Variant::NIL) {
  2672. Callable::CallError err;
  2673. Variant::construct(base_type.builtin_type, base, nullptr, 0, err);
  2674. if (err.error != Callable::CallError::CALL_OK) {
  2675. return;
  2676. }
  2677. }
  2678. List<MethodInfo> methods;
  2679. base.get_method_list(&methods);
  2680. for (const MethodInfo &E : methods) {
  2681. if (E.name == p_method) {
  2682. r_arghint = _make_arguments_hint(E, p_argidx);
  2683. return;
  2684. }
  2685. }
  2686. base_type.kind = GDScriptParser::DataType::UNRESOLVED;
  2687. } break;
  2688. default: {
  2689. base_type.kind = GDScriptParser::DataType::UNRESOLVED;
  2690. } break;
  2691. }
  2692. }
  2693. }
  2694. static bool _get_subscript_type(GDScriptParser::CompletionContext &p_context, const GDScriptParser::SubscriptNode *p_subscript, GDScriptParser::DataType &r_base_type, Variant *r_base = nullptr) {
  2695. if (p_context.base == nullptr) {
  2696. return false;
  2697. }
  2698. const GDScriptParser::GetNodeNode *get_node = nullptr;
  2699. switch (p_subscript->base->type) {
  2700. case GDScriptParser::Node::GET_NODE: {
  2701. get_node = static_cast<GDScriptParser::GetNodeNode *>(p_subscript->base);
  2702. } break;
  2703. case GDScriptParser::Node::IDENTIFIER: {
  2704. const GDScriptParser::IdentifierNode *identifier_node = static_cast<GDScriptParser::IdentifierNode *>(p_subscript->base);
  2705. switch (identifier_node->source) {
  2706. case GDScriptParser::IdentifierNode::Source::MEMBER_VARIABLE: {
  2707. if (p_context.current_class != nullptr) {
  2708. const StringName &member_name = identifier_node->name;
  2709. const GDScriptParser::ClassNode *current_class = p_context.current_class;
  2710. if (current_class->has_member(member_name)) {
  2711. const GDScriptParser::ClassNode::Member &member = current_class->get_member(member_name);
  2712. if (member.type == GDScriptParser::ClassNode::Member::VARIABLE) {
  2713. const GDScriptParser::VariableNode *variable = static_cast<GDScriptParser::VariableNode *>(member.variable);
  2714. if (variable->initializer && variable->initializer->type == GDScriptParser::Node::GET_NODE) {
  2715. get_node = static_cast<GDScriptParser::GetNodeNode *>(variable->initializer);
  2716. }
  2717. }
  2718. }
  2719. }
  2720. } break;
  2721. case GDScriptParser::IdentifierNode::Source::LOCAL_VARIABLE: {
  2722. if (identifier_node->next != nullptr && identifier_node->next->type == GDScriptParser::ClassNode::Node::GET_NODE) {
  2723. get_node = static_cast<GDScriptParser::GetNodeNode *>(identifier_node->next);
  2724. }
  2725. } break;
  2726. default: {
  2727. } break;
  2728. }
  2729. } break;
  2730. default: {
  2731. } break;
  2732. }
  2733. if (get_node != nullptr) {
  2734. const Object *node = p_context.base->call("get_node_or_null", NodePath(get_node->full_path));
  2735. if (node != nullptr) {
  2736. GDScriptParser::DataType assigned_type = _type_from_variant(node, p_context).type;
  2737. GDScriptParser::DataType base_type = p_subscript->base->datatype;
  2738. if (p_subscript->base->type == GDScriptParser::Node::IDENTIFIER && base_type.type_source == GDScriptParser::DataType::ANNOTATED_EXPLICIT && (assigned_type.kind != base_type.kind || assigned_type.script_path != base_type.script_path || assigned_type.native_type != base_type.native_type)) {
  2739. // Annotated type takes precedence.
  2740. return false;
  2741. }
  2742. if (r_base != nullptr) {
  2743. *r_base = node;
  2744. }
  2745. r_base_type.type_source = GDScriptParser::DataType::INFERRED;
  2746. r_base_type.builtin_type = Variant::OBJECT;
  2747. r_base_type.native_type = node->get_class_name();
  2748. Ref<Script> scr = node->get_script();
  2749. if (scr.is_null()) {
  2750. r_base_type.kind = GDScriptParser::DataType::NATIVE;
  2751. } else {
  2752. r_base_type.kind = GDScriptParser::DataType::SCRIPT;
  2753. r_base_type.script_type = scr;
  2754. }
  2755. return true;
  2756. }
  2757. }
  2758. return false;
  2759. }
  2760. static void _find_call_arguments(GDScriptParser::CompletionContext &p_context, const GDScriptParser::Node *p_call, int p_argidx, HashMap<String, ScriptLanguage::CodeCompletionOption> &r_result, bool &r_forced, String &r_arghint) {
  2761. if (p_call->type == GDScriptParser::Node::PRELOAD) {
  2762. if (p_argidx == 0 && bool(EDITOR_GET("text_editor/completion/complete_file_paths"))) {
  2763. _get_directory_contents(EditorFileSystem::get_singleton()->get_filesystem(), r_result);
  2764. }
  2765. MethodInfo mi(PropertyInfo(Variant::OBJECT, "resource", PROPERTY_HINT_RESOURCE_TYPE, "Resource"), "preload", PropertyInfo(Variant::STRING, "path"));
  2766. r_arghint = _make_arguments_hint(mi, p_argidx);
  2767. return;
  2768. } else if (p_call->type != GDScriptParser::Node::CALL) {
  2769. return;
  2770. }
  2771. Variant base;
  2772. GDScriptParser::DataType base_type;
  2773. bool _static = false;
  2774. const GDScriptParser::CallNode *call = static_cast<const GDScriptParser::CallNode *>(p_call);
  2775. GDScriptParser::Node::Type callee_type = call->get_callee_type();
  2776. if (callee_type == GDScriptParser::Node::SUBSCRIPT) {
  2777. const GDScriptParser::SubscriptNode *subscript = static_cast<const GDScriptParser::SubscriptNode *>(call->callee);
  2778. if (subscript->base != nullptr && subscript->base->type == GDScriptParser::Node::IDENTIFIER) {
  2779. const GDScriptParser::IdentifierNode *base_identifier = static_cast<const GDScriptParser::IdentifierNode *>(subscript->base);
  2780. Variant::Type method_type = GDScriptParser::get_builtin_type(base_identifier->name);
  2781. if (method_type < Variant::VARIANT_MAX) {
  2782. Variant v;
  2783. Callable::CallError err;
  2784. Variant::construct(method_type, v, nullptr, 0, err);
  2785. if (err.error != Callable::CallError::CALL_OK) {
  2786. return;
  2787. }
  2788. List<MethodInfo> methods;
  2789. v.get_method_list(&methods);
  2790. for (MethodInfo &E : methods) {
  2791. if (p_argidx >= E.arguments.size()) {
  2792. continue;
  2793. }
  2794. if (E.name == call->function_name) {
  2795. r_arghint += _make_arguments_hint(E, p_argidx);
  2796. return;
  2797. }
  2798. }
  2799. }
  2800. }
  2801. if (subscript->is_attribute) {
  2802. bool found_type = _get_subscript_type(p_context, subscript, base_type, &base);
  2803. if (!found_type) {
  2804. GDScriptCompletionIdentifier ci;
  2805. if (_guess_expression_type(p_context, subscript->base, ci)) {
  2806. base_type = ci.type;
  2807. base = ci.value;
  2808. } else {
  2809. return;
  2810. }
  2811. }
  2812. _static = base_type.is_meta_type;
  2813. }
  2814. } else if (Variant::has_utility_function(call->function_name)) {
  2815. MethodInfo info = Variant::get_utility_function_info(call->function_name);
  2816. r_arghint = _make_arguments_hint(info, p_argidx);
  2817. return;
  2818. } else if (GDScriptUtilityFunctions::function_exists(call->function_name)) {
  2819. MethodInfo info = GDScriptUtilityFunctions::get_function_info(call->function_name);
  2820. r_arghint = _make_arguments_hint(info, p_argidx);
  2821. return;
  2822. } else if (GDScriptParser::get_builtin_type(call->function_name) < Variant::VARIANT_MAX) {
  2823. // Complete constructor.
  2824. List<MethodInfo> constructors;
  2825. Variant::get_constructor_list(GDScriptParser::get_builtin_type(call->function_name), &constructors);
  2826. int i = 0;
  2827. for (const MethodInfo &E : constructors) {
  2828. if (p_argidx >= E.arguments.size()) {
  2829. continue;
  2830. }
  2831. if (i > 0) {
  2832. r_arghint += "\n";
  2833. }
  2834. r_arghint += _make_arguments_hint(E, p_argidx);
  2835. i++;
  2836. }
  2837. return;
  2838. } else if (call->is_super || callee_type == GDScriptParser::Node::IDENTIFIER) {
  2839. base = p_context.base;
  2840. if (p_context.current_class) {
  2841. base_type = p_context.current_class->get_datatype();
  2842. _static = !p_context.current_function || p_context.current_function->is_static;
  2843. }
  2844. } else {
  2845. return;
  2846. }
  2847. GDScriptCompletionIdentifier ci;
  2848. ci.type = base_type;
  2849. ci.value = base;
  2850. _find_call_arguments(p_context, ci, call->function_name, p_argidx, _static, r_result, r_arghint);
  2851. r_forced = r_result.size() > 0;
  2852. }
  2853. ::Error GDScriptLanguage::complete_code(const String &p_code, const String &p_path, Object *p_owner, List<ScriptLanguage::CodeCompletionOption> *r_options, bool &r_forced, String &r_call_hint) {
  2854. const String quote_style = EDITOR_GET("text_editor/completion/use_single_quotes") ? "'" : "\"";
  2855. GDScriptParser parser;
  2856. GDScriptAnalyzer analyzer(&parser);
  2857. parser.parse(p_code, p_path, true);
  2858. analyzer.analyze();
  2859. r_forced = false;
  2860. HashMap<String, ScriptLanguage::CodeCompletionOption> options;
  2861. GDScriptParser::CompletionContext completion_context = parser.get_completion_context();
  2862. if (completion_context.current_class != nullptr && completion_context.current_class->outer == nullptr) {
  2863. completion_context.base = p_owner;
  2864. }
  2865. bool is_function = false;
  2866. switch (completion_context.type) {
  2867. case GDScriptParser::COMPLETION_NONE:
  2868. break;
  2869. case GDScriptParser::COMPLETION_ANNOTATION: {
  2870. List<MethodInfo> annotations;
  2871. parser.get_annotation_list(&annotations);
  2872. for (const MethodInfo &E : annotations) {
  2873. ScriptLanguage::CodeCompletionOption option(E.name.substr(1), ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT);
  2874. if (E.arguments.size() > 0) {
  2875. option.insert_text += "(";
  2876. }
  2877. options.insert(option.display, option);
  2878. }
  2879. r_forced = true;
  2880. } break;
  2881. case GDScriptParser::COMPLETION_ANNOTATION_ARGUMENTS: {
  2882. if (completion_context.node == nullptr || completion_context.node->type != GDScriptParser::Node::ANNOTATION) {
  2883. break;
  2884. }
  2885. const GDScriptParser::AnnotationNode *annotation = static_cast<const GDScriptParser::AnnotationNode *>(completion_context.node);
  2886. _find_annotation_arguments(annotation, completion_context.current_argument, quote_style, options, r_call_hint);
  2887. r_forced = true;
  2888. } break;
  2889. case GDScriptParser::COMPLETION_BUILT_IN_TYPE_CONSTANT_OR_STATIC_METHOD: {
  2890. // Constants.
  2891. {
  2892. List<StringName> constants;
  2893. Variant::get_constants_for_type(completion_context.builtin_type, &constants);
  2894. for (const StringName &E : constants) {
  2895. ScriptLanguage::CodeCompletionOption option(E, ScriptLanguage::CODE_COMPLETION_KIND_CONSTANT);
  2896. bool valid = false;
  2897. Variant default_value = Variant::get_constant_value(completion_context.builtin_type, E, &valid);
  2898. if (valid) {
  2899. option.default_value = default_value;
  2900. }
  2901. options.insert(option.display, option);
  2902. }
  2903. }
  2904. // Methods.
  2905. {
  2906. List<StringName> methods;
  2907. Variant::get_builtin_method_list(completion_context.builtin_type, &methods);
  2908. for (const StringName &E : methods) {
  2909. if (Variant::is_builtin_method_static(completion_context.builtin_type, E)) {
  2910. ScriptLanguage::CodeCompletionOption option(E, ScriptLanguage::CODE_COMPLETION_KIND_FUNCTION);
  2911. if (Variant::get_builtin_method_argument_count(completion_context.builtin_type, E) > 0 || Variant::is_builtin_method_vararg(completion_context.builtin_type, E)) {
  2912. option.insert_text += "(";
  2913. } else {
  2914. option.insert_text += "()";
  2915. }
  2916. options.insert(option.display, option);
  2917. }
  2918. }
  2919. }
  2920. } break;
  2921. case GDScriptParser::COMPLETION_INHERIT_TYPE: {
  2922. _list_available_types(true, completion_context, options);
  2923. r_forced = true;
  2924. } break;
  2925. case GDScriptParser::COMPLETION_TYPE_NAME_OR_VOID: {
  2926. ScriptLanguage::CodeCompletionOption option("void", ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT);
  2927. options.insert(option.display, option);
  2928. }
  2929. [[fallthrough]];
  2930. case GDScriptParser::COMPLETION_TYPE_NAME: {
  2931. _list_available_types(false, completion_context, options);
  2932. r_forced = true;
  2933. } break;
  2934. case GDScriptParser::COMPLETION_PROPERTY_DECLARATION_OR_TYPE: {
  2935. _list_available_types(false, completion_context, options);
  2936. ScriptLanguage::CodeCompletionOption get("get", ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT);
  2937. options.insert(get.display, get);
  2938. ScriptLanguage::CodeCompletionOption set("set", ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT);
  2939. options.insert(set.display, set);
  2940. r_forced = true;
  2941. } break;
  2942. case GDScriptParser::COMPLETION_PROPERTY_DECLARATION: {
  2943. ScriptLanguage::CodeCompletionOption get("get", ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT);
  2944. options.insert(get.display, get);
  2945. ScriptLanguage::CodeCompletionOption set("set", ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT);
  2946. options.insert(set.display, set);
  2947. r_forced = true;
  2948. } break;
  2949. case GDScriptParser::COMPLETION_PROPERTY_METHOD: {
  2950. if (!completion_context.current_class) {
  2951. break;
  2952. }
  2953. for (int i = 0; i < completion_context.current_class->members.size(); i++) {
  2954. const GDScriptParser::ClassNode::Member &member = completion_context.current_class->members[i];
  2955. if (member.type != GDScriptParser::ClassNode::Member::FUNCTION) {
  2956. continue;
  2957. }
  2958. if (member.function->is_static) {
  2959. continue;
  2960. }
  2961. ScriptLanguage::CodeCompletionOption option(member.function->identifier->name, ScriptLanguage::CODE_COMPLETION_KIND_FUNCTION);
  2962. options.insert(option.display, option);
  2963. }
  2964. r_forced = true;
  2965. } break;
  2966. case GDScriptParser::COMPLETION_ASSIGN: {
  2967. GDScriptCompletionIdentifier type;
  2968. if (!completion_context.node || completion_context.node->type != GDScriptParser::Node::ASSIGNMENT) {
  2969. break;
  2970. }
  2971. if (!_guess_expression_type(completion_context, static_cast<const GDScriptParser::AssignmentNode *>(completion_context.node)->assignee, type)) {
  2972. _find_identifiers(completion_context, false, options, 0);
  2973. r_forced = true;
  2974. break;
  2975. }
  2976. if (!type.enumeration.is_empty()) {
  2977. _find_enumeration_candidates(completion_context, type.enumeration, options);
  2978. r_forced = options.size() > 0;
  2979. } else {
  2980. _find_identifiers(completion_context, false, options, 0);
  2981. r_forced = true;
  2982. }
  2983. } break;
  2984. case GDScriptParser::COMPLETION_METHOD:
  2985. is_function = true;
  2986. [[fallthrough]];
  2987. case GDScriptParser::COMPLETION_IDENTIFIER: {
  2988. _find_identifiers(completion_context, is_function, options, 0);
  2989. } break;
  2990. case GDScriptParser::COMPLETION_ATTRIBUTE_METHOD:
  2991. is_function = true;
  2992. [[fallthrough]];
  2993. case GDScriptParser::COMPLETION_ATTRIBUTE: {
  2994. r_forced = true;
  2995. const GDScriptParser::SubscriptNode *attr = static_cast<const GDScriptParser::SubscriptNode *>(completion_context.node);
  2996. if (attr->base) {
  2997. GDScriptCompletionIdentifier base;
  2998. bool found_type = _get_subscript_type(completion_context, attr, base.type);
  2999. if (!found_type && !_guess_expression_type(completion_context, attr->base, base)) {
  3000. break;
  3001. }
  3002. _find_identifiers_in_base(base, is_function, false, options, 0);
  3003. }
  3004. } break;
  3005. case GDScriptParser::COMPLETION_SUBSCRIPT: {
  3006. const GDScriptParser::SubscriptNode *subscript = static_cast<const GDScriptParser::SubscriptNode *>(completion_context.node);
  3007. GDScriptCompletionIdentifier base;
  3008. const bool res = _guess_expression_type(completion_context, subscript->base, base);
  3009. // If the type is not known, we assume it is BUILTIN, since indices on arrays is the most common use case.
  3010. if (!subscript->is_attribute && (!res || base.type.kind == GDScriptParser::DataType::BUILTIN || base.type.is_variant())) {
  3011. if (base.value.get_type() == Variant::DICTIONARY) {
  3012. List<PropertyInfo> members;
  3013. base.value.get_property_list(&members);
  3014. for (const PropertyInfo &E : members) {
  3015. ScriptLanguage::CodeCompletionOption option(E.name.quote(quote_style), ScriptLanguage::CODE_COMPLETION_KIND_MEMBER, ScriptLanguage::LOCATION_LOCAL);
  3016. options.insert(option.display, option);
  3017. }
  3018. }
  3019. if (!subscript->index || subscript->index->type != GDScriptParser::Node::LITERAL) {
  3020. _find_identifiers(completion_context, false, options, 0);
  3021. }
  3022. } else if (res) {
  3023. if (!subscript->is_attribute) {
  3024. // Quote the options if they are not accessed as attribute.
  3025. HashMap<String, ScriptLanguage::CodeCompletionOption> opt;
  3026. _find_identifiers_in_base(base, false, false, opt, 0);
  3027. for (const KeyValue<String, CodeCompletionOption> &E : opt) {
  3028. ScriptLanguage::CodeCompletionOption option(E.value.insert_text.quote(quote_style), E.value.kind, E.value.location);
  3029. options.insert(option.display, option);
  3030. }
  3031. } else {
  3032. _find_identifiers_in_base(base, false, false, options, 0);
  3033. }
  3034. }
  3035. } break;
  3036. case GDScriptParser::COMPLETION_TYPE_ATTRIBUTE: {
  3037. if (!completion_context.current_class) {
  3038. break;
  3039. }
  3040. const GDScriptParser::TypeNode *type = static_cast<const GDScriptParser::TypeNode *>(completion_context.node);
  3041. bool found = true;
  3042. GDScriptCompletionIdentifier base;
  3043. base.type.kind = GDScriptParser::DataType::CLASS;
  3044. base.type.type_source = GDScriptParser::DataType::INFERRED;
  3045. base.type.is_constant = true;
  3046. if (completion_context.current_argument == 1) {
  3047. StringName type_name = type->type_chain[0]->name;
  3048. if (ClassDB::class_exists(type_name)) {
  3049. base.type.kind = GDScriptParser::DataType::NATIVE;
  3050. base.type.native_type = type_name;
  3051. } else if (ScriptServer::is_global_class(type_name)) {
  3052. base.type.kind = GDScriptParser::DataType::SCRIPT;
  3053. String scr_path = ScriptServer::get_global_class_path(type_name);
  3054. base.type.script_type = ResourceLoader::load(scr_path);
  3055. }
  3056. }
  3057. if (base.type.kind == GDScriptParser::DataType::CLASS) {
  3058. base.type.class_type = completion_context.current_class;
  3059. base.value = completion_context.base;
  3060. for (int i = 0; i < completion_context.current_argument; i++) {
  3061. GDScriptCompletionIdentifier ci;
  3062. if (!_guess_identifier_type_from_base(completion_context, base, type->type_chain[i]->name, ci)) {
  3063. found = false;
  3064. break;
  3065. }
  3066. base = ci;
  3067. }
  3068. }
  3069. if (found) {
  3070. _find_identifiers_in_base(base, false, true, options, 0);
  3071. }
  3072. r_forced = true;
  3073. } break;
  3074. case GDScriptParser::COMPLETION_RESOURCE_PATH: {
  3075. if (EDITOR_GET("text_editor/completion/complete_file_paths")) {
  3076. _get_directory_contents(EditorFileSystem::get_singleton()->get_filesystem(), options);
  3077. r_forced = true;
  3078. }
  3079. } break;
  3080. case GDScriptParser::COMPLETION_CALL_ARGUMENTS: {
  3081. if (!completion_context.node) {
  3082. break;
  3083. }
  3084. _find_call_arguments(completion_context, completion_context.node, completion_context.current_argument, options, r_forced, r_call_hint);
  3085. } break;
  3086. case GDScriptParser::COMPLETION_OVERRIDE_METHOD: {
  3087. GDScriptParser::DataType native_type = completion_context.current_class->base_type;
  3088. while (native_type.is_set() && native_type.kind != GDScriptParser::DataType::NATIVE) {
  3089. switch (native_type.kind) {
  3090. case GDScriptParser::DataType::CLASS: {
  3091. native_type = native_type.class_type->base_type;
  3092. } break;
  3093. default: {
  3094. native_type.kind = GDScriptParser::DataType::UNRESOLVED;
  3095. } break;
  3096. }
  3097. }
  3098. if (!native_type.is_set()) {
  3099. break;
  3100. }
  3101. StringName class_name = native_type.native_type;
  3102. if (!ClassDB::class_exists(class_name)) {
  3103. break;
  3104. }
  3105. bool use_type_hint = EditorSettings::get_singleton()->get_setting("text_editor/completion/add_type_hints").operator bool();
  3106. List<MethodInfo> virtual_methods;
  3107. ClassDB::get_virtual_methods(class_name, &virtual_methods);
  3108. {
  3109. // Not truly a virtual method, but can also be "overridden".
  3110. MethodInfo static_init("_static_init");
  3111. static_init.return_val.type = Variant::NIL;
  3112. static_init.flags |= METHOD_FLAG_STATIC | METHOD_FLAG_VIRTUAL;
  3113. virtual_methods.push_back(static_init);
  3114. }
  3115. for (const MethodInfo &mi : virtual_methods) {
  3116. String method_hint = mi.name;
  3117. if (method_hint.contains(":")) {
  3118. method_hint = method_hint.get_slice(":", 0);
  3119. }
  3120. method_hint += "(";
  3121. for (List<PropertyInfo>::ConstIterator arg_itr = mi.arguments.begin(); arg_itr != mi.arguments.end(); ++arg_itr) {
  3122. if (arg_itr != mi.arguments.begin()) {
  3123. method_hint += ", ";
  3124. }
  3125. String arg = arg_itr->name;
  3126. if (arg.contains(":")) {
  3127. arg = arg.substr(0, arg.find_char(':'));
  3128. }
  3129. method_hint += arg;
  3130. if (use_type_hint) {
  3131. method_hint += ": " + _get_visual_datatype(*arg_itr, true, class_name);
  3132. }
  3133. }
  3134. method_hint += ")";
  3135. if (use_type_hint) {
  3136. method_hint += " -> " + _get_visual_datatype(mi.return_val, false, class_name);
  3137. }
  3138. method_hint += ":";
  3139. ScriptLanguage::CodeCompletionOption option(method_hint, ScriptLanguage::CODE_COMPLETION_KIND_FUNCTION);
  3140. options.insert(option.display, option);
  3141. }
  3142. } break;
  3143. case GDScriptParser::COMPLETION_GET_NODE: {
  3144. // Handles the `$Node/Path` or `$"Some NodePath"` syntax specifically.
  3145. if (p_owner) {
  3146. List<String> opts;
  3147. p_owner->get_argument_options("get_node", 0, &opts);
  3148. bool for_unique_name = false;
  3149. if (completion_context.node != nullptr && completion_context.node->type == GDScriptParser::Node::GET_NODE && !static_cast<GDScriptParser::GetNodeNode *>(completion_context.node)->use_dollar) {
  3150. for_unique_name = true;
  3151. }
  3152. for (const String &E : opts) {
  3153. r_forced = true;
  3154. String opt = E.strip_edges();
  3155. if (opt.is_quoted()) {
  3156. // Remove quotes so that we can handle user preferred quote style,
  3157. // or handle NodePaths which are valid identifiers and don't need quotes.
  3158. opt = opt.unquote();
  3159. }
  3160. if (for_unique_name) {
  3161. if (!opt.begins_with("%")) {
  3162. continue;
  3163. }
  3164. opt = opt.substr(1);
  3165. }
  3166. // The path needs quotes if at least one of its components (excluding `%` prefix and `/` separations)
  3167. // is not a valid identifier.
  3168. bool path_needs_quote = false;
  3169. for (const String &part : opt.trim_prefix("%").split("/")) {
  3170. if (!part.is_valid_ascii_identifier()) {
  3171. path_needs_quote = true;
  3172. break;
  3173. }
  3174. }
  3175. if (path_needs_quote) {
  3176. // Ignore quote_style and just use double quotes for paths with apostrophes.
  3177. // Double quotes don't need to be checked because they're not valid in node and property names.
  3178. opt = opt.quote(opt.contains("'") ? "\"" : quote_style); // Handle user preference.
  3179. }
  3180. ScriptLanguage::CodeCompletionOption option(opt, ScriptLanguage::CODE_COMPLETION_KIND_NODE_PATH);
  3181. options.insert(option.display, option);
  3182. }
  3183. if (!for_unique_name) {
  3184. // Get autoloads.
  3185. for (const KeyValue<StringName, ProjectSettings::AutoloadInfo> &E : ProjectSettings::get_singleton()->get_autoload_list()) {
  3186. String path = "/root/" + E.key;
  3187. ScriptLanguage::CodeCompletionOption option(path.quote(quote_style), ScriptLanguage::CODE_COMPLETION_KIND_NODE_PATH);
  3188. options.insert(option.display, option);
  3189. }
  3190. }
  3191. }
  3192. } break;
  3193. case GDScriptParser::COMPLETION_SUPER_METHOD: {
  3194. if (!completion_context.current_class) {
  3195. break;
  3196. }
  3197. _find_identifiers_in_class(completion_context.current_class, true, false, false, true, options, 0);
  3198. } break;
  3199. }
  3200. for (const KeyValue<String, ScriptLanguage::CodeCompletionOption> &E : options) {
  3201. r_options->push_back(E.value);
  3202. }
  3203. return OK;
  3204. }
  3205. #else // !TOOLS_ENABLED
  3206. Error GDScriptLanguage::complete_code(const String &p_code, const String &p_path, Object *p_owner, List<ScriptLanguage::CodeCompletionOption> *r_options, bool &r_forced, String &r_call_hint) {
  3207. return OK;
  3208. }
  3209. #endif // TOOLS_ENABLED
  3210. //////// END COMPLETION //////////
  3211. String GDScriptLanguage::_get_indentation() const {
  3212. #ifdef TOOLS_ENABLED
  3213. if (Engine::get_singleton()->is_editor_hint()) {
  3214. bool use_space_indentation = EDITOR_GET("text_editor/behavior/indent/type");
  3215. if (use_space_indentation) {
  3216. int indent_size = EDITOR_GET("text_editor/behavior/indent/size");
  3217. return String(" ").repeat(indent_size);
  3218. }
  3219. }
  3220. #endif
  3221. return "\t";
  3222. }
  3223. void GDScriptLanguage::auto_indent_code(String &p_code, int p_from_line, int p_to_line) const {
  3224. String indent = _get_indentation();
  3225. Vector<String> lines = p_code.split("\n");
  3226. List<int> indent_stack;
  3227. for (int i = 0; i < lines.size(); i++) {
  3228. String l = lines[i];
  3229. int tc = 0;
  3230. for (int j = 0; j < l.length(); j++) {
  3231. if (l[j] == ' ' || l[j] == '\t') {
  3232. tc++;
  3233. } else {
  3234. break;
  3235. }
  3236. }
  3237. String st = l.substr(tc, l.length()).strip_edges();
  3238. if (st.is_empty() || st.begins_with("#")) {
  3239. continue; //ignore!
  3240. }
  3241. int ilevel = 0;
  3242. if (indent_stack.size()) {
  3243. ilevel = indent_stack.back()->get();
  3244. }
  3245. if (tc > ilevel) {
  3246. indent_stack.push_back(tc);
  3247. } else if (tc < ilevel) {
  3248. while (indent_stack.size() && indent_stack.back()->get() > tc) {
  3249. indent_stack.pop_back();
  3250. }
  3251. if (indent_stack.size() && indent_stack.back()->get() != tc) {
  3252. indent_stack.push_back(tc); // this is not right but gets the job done
  3253. }
  3254. }
  3255. if (i >= p_from_line) {
  3256. l = indent.repeat(indent_stack.size()) + st;
  3257. } else if (i > p_to_line) {
  3258. break;
  3259. }
  3260. lines.write[i] = l;
  3261. }
  3262. p_code = "";
  3263. for (int i = 0; i < lines.size(); i++) {
  3264. if (i > 0) {
  3265. p_code += "\n";
  3266. }
  3267. p_code += lines[i];
  3268. }
  3269. }
  3270. #ifdef TOOLS_ENABLED
  3271. static Error _lookup_symbol_from_base(const GDScriptParser::DataType &p_base, const String &p_symbol, bool p_is_function, GDScriptLanguage::LookupResult &r_result) {
  3272. GDScriptParser::DataType base_type = p_base;
  3273. while (base_type.is_set()) {
  3274. switch (base_type.kind) {
  3275. case GDScriptParser::DataType::CLASS: {
  3276. if (base_type.class_type) {
  3277. String name = p_symbol;
  3278. if (name == "new") {
  3279. name = "_init";
  3280. }
  3281. if (base_type.class_type->has_member(name)) {
  3282. r_result.type = ScriptLanguage::LOOKUP_RESULT_SCRIPT_LOCATION;
  3283. r_result.location = base_type.class_type->get_member(name).get_line();
  3284. r_result.class_path = base_type.script_path;
  3285. Error err = OK;
  3286. r_result.script = GDScriptCache::get_shallow_script(r_result.class_path, err);
  3287. return err;
  3288. }
  3289. base_type = base_type.class_type->base_type;
  3290. }
  3291. } break;
  3292. case GDScriptParser::DataType::SCRIPT: {
  3293. Ref<Script> scr = base_type.script_type;
  3294. if (scr.is_valid()) {
  3295. int line = scr->get_member_line(p_symbol);
  3296. if (line >= 0) {
  3297. r_result.type = ScriptLanguage::LOOKUP_RESULT_SCRIPT_LOCATION;
  3298. r_result.location = line;
  3299. r_result.script = scr;
  3300. return OK;
  3301. }
  3302. Ref<Script> base_script = scr->get_base_script();
  3303. if (base_script.is_valid()) {
  3304. base_type.script_type = base_script;
  3305. } else {
  3306. base_type.kind = GDScriptParser::DataType::NATIVE;
  3307. base_type.builtin_type = Variant::OBJECT;
  3308. base_type.native_type = scr->get_instance_base_type();
  3309. }
  3310. } else {
  3311. base_type.kind = GDScriptParser::DataType::UNRESOLVED;
  3312. }
  3313. } break;
  3314. case GDScriptParser::DataType::NATIVE: {
  3315. StringName class_name = base_type.native_type;
  3316. if (!ClassDB::class_exists(class_name)) {
  3317. base_type.kind = GDScriptParser::DataType::UNRESOLVED;
  3318. break;
  3319. }
  3320. if (ClassDB::has_method(class_name, p_symbol, true)) {
  3321. r_result.type = ScriptLanguage::LOOKUP_RESULT_CLASS_METHOD;
  3322. r_result.class_name = base_type.native_type;
  3323. r_result.class_member = p_symbol;
  3324. return OK;
  3325. }
  3326. List<MethodInfo> virtual_methods;
  3327. ClassDB::get_virtual_methods(class_name, &virtual_methods, true);
  3328. for (const MethodInfo &E : virtual_methods) {
  3329. if (E.name == p_symbol) {
  3330. r_result.type = ScriptLanguage::LOOKUP_RESULT_CLASS_METHOD;
  3331. r_result.class_name = base_type.native_type;
  3332. r_result.class_member = p_symbol;
  3333. return OK;
  3334. }
  3335. }
  3336. if (ClassDB::has_signal(class_name, p_symbol, true)) {
  3337. r_result.type = ScriptLanguage::LOOKUP_RESULT_CLASS_SIGNAL;
  3338. r_result.class_name = base_type.native_type;
  3339. r_result.class_member = p_symbol;
  3340. return OK;
  3341. }
  3342. List<StringName> enums;
  3343. ClassDB::get_enum_list(class_name, &enums);
  3344. for (const StringName &E : enums) {
  3345. if (E == p_symbol) {
  3346. r_result.type = ScriptLanguage::LOOKUP_RESULT_CLASS_ENUM;
  3347. r_result.class_name = base_type.native_type;
  3348. r_result.class_member = p_symbol;
  3349. return OK;
  3350. }
  3351. }
  3352. if (!String(ClassDB::get_integer_constant_enum(class_name, p_symbol, true)).is_empty()) {
  3353. r_result.type = ScriptLanguage::LOOKUP_RESULT_CLASS_CONSTANT;
  3354. r_result.class_name = base_type.native_type;
  3355. r_result.class_member = p_symbol;
  3356. return OK;
  3357. }
  3358. List<String> constants;
  3359. ClassDB::get_integer_constant_list(class_name, &constants, true);
  3360. for (const String &E : constants) {
  3361. if (E == p_symbol) {
  3362. r_result.type = ScriptLanguage::LOOKUP_RESULT_CLASS_CONSTANT;
  3363. r_result.class_name = base_type.native_type;
  3364. r_result.class_member = p_symbol;
  3365. return OK;
  3366. }
  3367. }
  3368. if (ClassDB::has_property(class_name, p_symbol, true)) {
  3369. PropertyInfo prop_info;
  3370. ClassDB::get_property_info(class_name, p_symbol, &prop_info, true);
  3371. if (prop_info.usage & PROPERTY_USAGE_INTERNAL) {
  3372. return ERR_CANT_RESOLVE;
  3373. }
  3374. r_result.type = ScriptLanguage::LOOKUP_RESULT_CLASS_PROPERTY;
  3375. r_result.class_name = base_type.native_type;
  3376. r_result.class_member = p_symbol;
  3377. return OK;
  3378. }
  3379. StringName parent = ClassDB::get_parent_class(class_name);
  3380. if (parent != StringName()) {
  3381. base_type.native_type = parent;
  3382. } else {
  3383. base_type.kind = GDScriptParser::DataType::UNRESOLVED;
  3384. }
  3385. } break;
  3386. case GDScriptParser::DataType::BUILTIN: {
  3387. base_type.kind = GDScriptParser::DataType::UNRESOLVED;
  3388. if (Variant::has_constant(base_type.builtin_type, p_symbol)) {
  3389. r_result.type = ScriptLanguage::LOOKUP_RESULT_CLASS_CONSTANT;
  3390. r_result.class_name = Variant::get_type_name(base_type.builtin_type);
  3391. r_result.class_member = p_symbol;
  3392. return OK;
  3393. }
  3394. Variant v;
  3395. Ref<RefCounted> v_ref;
  3396. if (base_type.builtin_type == Variant::OBJECT) {
  3397. v_ref.instantiate();
  3398. v = v_ref;
  3399. } else {
  3400. Callable::CallError err;
  3401. Variant::construct(base_type.builtin_type, v, nullptr, 0, err);
  3402. if (err.error != Callable::CallError::CALL_OK) {
  3403. break;
  3404. }
  3405. }
  3406. if (v.has_method(p_symbol)) {
  3407. r_result.type = ScriptLanguage::LOOKUP_RESULT_CLASS_METHOD;
  3408. r_result.class_name = Variant::get_type_name(base_type.builtin_type);
  3409. r_result.class_member = p_symbol;
  3410. return OK;
  3411. }
  3412. bool valid = false;
  3413. v.get(p_symbol, &valid);
  3414. if (valid) {
  3415. r_result.type = ScriptLanguage::LOOKUP_RESULT_CLASS_PROPERTY;
  3416. r_result.class_name = Variant::get_type_name(base_type.builtin_type);
  3417. r_result.class_member = p_symbol;
  3418. return OK;
  3419. }
  3420. } break;
  3421. case GDScriptParser::DataType::ENUM: {
  3422. if (base_type.class_type && base_type.class_type->has_member(base_type.enum_type)) {
  3423. GDScriptParser::EnumNode *base_enum = base_type.class_type->get_member(base_type.enum_type).m_enum;
  3424. for (const GDScriptParser::EnumNode::Value &value : base_enum->values) {
  3425. if (value.identifier && value.identifier->name == p_symbol) {
  3426. r_result.type = ScriptLanguage::LOOKUP_RESULT_SCRIPT_LOCATION;
  3427. r_result.class_path = base_type.script_path;
  3428. r_result.location = value.line;
  3429. Error err = OK;
  3430. r_result.script = GDScriptCache::get_shallow_script(r_result.class_path, err);
  3431. return err;
  3432. }
  3433. }
  3434. } else if (base_type.enum_values.has(p_symbol)) {
  3435. r_result.type = ScriptLanguage::LOOKUP_RESULT_CLASS_CONSTANT;
  3436. r_result.class_name = String(base_type.native_type).get_slicec('.', 0);
  3437. r_result.class_member = p_symbol;
  3438. return OK;
  3439. }
  3440. base_type.kind = GDScriptParser::DataType::UNRESOLVED;
  3441. } break;
  3442. default: {
  3443. base_type.kind = GDScriptParser::DataType::UNRESOLVED;
  3444. } break;
  3445. }
  3446. }
  3447. return ERR_CANT_RESOLVE;
  3448. }
  3449. ::Error GDScriptLanguage::lookup_code(const String &p_code, const String &p_symbol, const String &p_path, Object *p_owner, LookupResult &r_result) {
  3450. // Before parsing, try the usual stuff.
  3451. if (ClassDB::class_exists(p_symbol)) {
  3452. r_result.type = ScriptLanguage::LOOKUP_RESULT_CLASS;
  3453. r_result.class_name = p_symbol;
  3454. return OK;
  3455. }
  3456. if (Variant::get_type_by_name(p_symbol) < Variant::VARIANT_MAX) {
  3457. r_result.type = ScriptLanguage::LOOKUP_RESULT_CLASS;
  3458. r_result.class_name = p_symbol;
  3459. return OK;
  3460. }
  3461. if ("Variant" == p_symbol) {
  3462. r_result.type = ScriptLanguage::LOOKUP_RESULT_CLASS;
  3463. r_result.class_name = "Variant";
  3464. return OK;
  3465. }
  3466. if ("PI" == p_symbol || "TAU" == p_symbol || "INF" == p_symbol || "NAN" == p_symbol) {
  3467. r_result.type = ScriptLanguage::LOOKUP_RESULT_CLASS_CONSTANT;
  3468. r_result.class_name = "@GDScript";
  3469. r_result.class_member = p_symbol;
  3470. return OK;
  3471. }
  3472. GDScriptParser parser;
  3473. parser.parse(p_code, p_path, true);
  3474. GDScriptParser::CompletionContext context = parser.get_completion_context();
  3475. context.base = p_owner;
  3476. // Allows class functions with the names like built-ins to be handled properly.
  3477. if (context.type != GDScriptParser::COMPLETION_ATTRIBUTE) {
  3478. // Need special checks for assert and preload as they are technically
  3479. // keywords, so are not registered in GDScriptUtilityFunctions.
  3480. if (GDScriptUtilityFunctions::function_exists(p_symbol) || "assert" == p_symbol || "preload" == p_symbol) {
  3481. r_result.type = ScriptLanguage::LOOKUP_RESULT_CLASS_METHOD;
  3482. r_result.class_name = "@GDScript";
  3483. r_result.class_member = p_symbol;
  3484. return OK;
  3485. }
  3486. }
  3487. GDScriptAnalyzer analyzer(&parser);
  3488. analyzer.analyze();
  3489. if (context.current_class && context.current_class->extends.size() > 0) {
  3490. StringName class_name = context.current_class->extends[0]->name;
  3491. bool success = false;
  3492. ClassDB::get_integer_constant(class_name, p_symbol, &success);
  3493. if (success) {
  3494. r_result.type = ScriptLanguage::LOOKUP_RESULT_CLASS_CONSTANT;
  3495. r_result.class_name = class_name;
  3496. r_result.class_member = p_symbol;
  3497. return OK;
  3498. }
  3499. do {
  3500. List<StringName> enums;
  3501. ClassDB::get_enum_list(class_name, &enums, true);
  3502. for (const StringName &enum_name : enums) {
  3503. if (enum_name == p_symbol) {
  3504. r_result.type = ScriptLanguage::LOOKUP_RESULT_CLASS_ENUM;
  3505. r_result.class_name = class_name;
  3506. r_result.class_member = p_symbol;
  3507. return OK;
  3508. }
  3509. }
  3510. class_name = ClassDB::get_parent_class_nocheck(class_name);
  3511. } while (class_name != StringName());
  3512. }
  3513. const GDScriptParser::TypeNode *type_node = dynamic_cast<const GDScriptParser::TypeNode *>(context.node);
  3514. if (type_node != nullptr && !type_node->type_chain.is_empty()) {
  3515. StringName class_name = type_node->type_chain[0]->name;
  3516. if (ScriptServer::is_global_class(class_name)) {
  3517. class_name = ScriptServer::get_global_class_native_base(class_name);
  3518. }
  3519. do {
  3520. List<StringName> enums;
  3521. ClassDB::get_enum_list(class_name, &enums, true);
  3522. for (const StringName &enum_name : enums) {
  3523. if (enum_name == p_symbol) {
  3524. r_result.type = ScriptLanguage::LOOKUP_RESULT_CLASS_ENUM;
  3525. r_result.class_name = class_name;
  3526. r_result.class_member = p_symbol;
  3527. return OK;
  3528. }
  3529. }
  3530. class_name = ClassDB::get_parent_class_nocheck(class_name);
  3531. } while (class_name != StringName());
  3532. }
  3533. bool is_function = false;
  3534. switch (context.type) {
  3535. case GDScriptParser::COMPLETION_BUILT_IN_TYPE_CONSTANT_OR_STATIC_METHOD: {
  3536. if (!Variant::has_builtin_method(context.builtin_type, StringName(p_symbol))) {
  3537. // A constant.
  3538. r_result.type = ScriptLanguage::LOOKUP_RESULT_CLASS_CONSTANT;
  3539. r_result.class_name = Variant::get_type_name(context.builtin_type);
  3540. r_result.class_member = p_symbol;
  3541. return OK;
  3542. }
  3543. // A method.
  3544. GDScriptParser::DataType base_type;
  3545. base_type.kind = GDScriptParser::DataType::BUILTIN;
  3546. base_type.builtin_type = context.builtin_type;
  3547. if (_lookup_symbol_from_base(base_type, p_symbol, true, r_result) == OK) {
  3548. return OK;
  3549. }
  3550. } break;
  3551. case GDScriptParser::COMPLETION_SUPER_METHOD:
  3552. case GDScriptParser::COMPLETION_METHOD: {
  3553. is_function = true;
  3554. [[fallthrough]];
  3555. }
  3556. case GDScriptParser::COMPLETION_ASSIGN:
  3557. case GDScriptParser::COMPLETION_CALL_ARGUMENTS:
  3558. case GDScriptParser::COMPLETION_IDENTIFIER:
  3559. case GDScriptParser::COMPLETION_PROPERTY_METHOD:
  3560. case GDScriptParser::COMPLETION_SUBSCRIPT: {
  3561. GDScriptParser::DataType base_type;
  3562. if (context.current_class) {
  3563. if (context.type != GDScriptParser::COMPLETION_SUPER_METHOD) {
  3564. base_type = context.current_class->get_datatype();
  3565. } else {
  3566. base_type = context.current_class->base_type;
  3567. }
  3568. } else {
  3569. break;
  3570. }
  3571. if (!is_function && context.current_suite) {
  3572. // Lookup local variables.
  3573. const GDScriptParser::SuiteNode *suite = context.current_suite;
  3574. while (suite) {
  3575. if (suite->has_local(p_symbol)) {
  3576. r_result.type = ScriptLanguage::LOOKUP_RESULT_SCRIPT_LOCATION;
  3577. r_result.location = suite->get_local(p_symbol).start_line;
  3578. return OK;
  3579. }
  3580. suite = suite->parent_block;
  3581. }
  3582. }
  3583. if (_lookup_symbol_from_base(base_type, p_symbol, is_function, r_result) == OK) {
  3584. return OK;
  3585. }
  3586. if (!is_function) {
  3587. // Guess in autoloads as singletons.
  3588. if (ProjectSettings::get_singleton()->has_autoload(p_symbol)) {
  3589. const ProjectSettings::AutoloadInfo &autoload = ProjectSettings::get_singleton()->get_autoload(p_symbol);
  3590. if (autoload.is_singleton) {
  3591. String scr_path = autoload.path;
  3592. if (!scr_path.ends_with(".gd")) {
  3593. // Not a script, try find the script anyway,
  3594. // may have some success.
  3595. scr_path = scr_path.get_basename() + ".gd";
  3596. }
  3597. if (FileAccess::exists(scr_path)) {
  3598. r_result.type = ScriptLanguage::LOOKUP_RESULT_SCRIPT_LOCATION;
  3599. r_result.location = 0;
  3600. r_result.script = ResourceLoader::load(scr_path);
  3601. return OK;
  3602. }
  3603. }
  3604. }
  3605. // Global.
  3606. HashMap<StringName, int> classes = GDScriptLanguage::get_singleton()->get_global_map();
  3607. if (classes.has(p_symbol)) {
  3608. Variant value = GDScriptLanguage::get_singleton()->get_global_array()[classes[p_symbol]];
  3609. if (value.get_type() == Variant::OBJECT) {
  3610. Object *obj = value;
  3611. if (obj) {
  3612. if (Object::cast_to<GDScriptNativeClass>(obj)) {
  3613. r_result.type = ScriptLanguage::LOOKUP_RESULT_CLASS;
  3614. r_result.class_name = Object::cast_to<GDScriptNativeClass>(obj)->get_name();
  3615. } else {
  3616. r_result.type = ScriptLanguage::LOOKUP_RESULT_CLASS;
  3617. r_result.class_name = obj->get_class();
  3618. }
  3619. // proxy class remove the underscore.
  3620. if (r_result.class_name.begins_with("_")) {
  3621. r_result.class_name = r_result.class_name.substr(1);
  3622. }
  3623. return OK;
  3624. }
  3625. } else {
  3626. /*
  3627. // Because get_integer_constant_enum and get_integer_constant don't work on @GlobalScope
  3628. // We cannot determine the exact nature of the identifier here
  3629. // Otherwise these codes would work
  3630. StringName enumName = ClassDB::get_integer_constant_enum("@GlobalScope", p_symbol, true);
  3631. if (enumName != nullptr) {
  3632. r_result.type = ScriptLanguage::LOOKUP_RESULT_CLASS_ENUM;
  3633. r_result.class_name = "@GlobalScope";
  3634. r_result.class_member = enumName;
  3635. return OK;
  3636. }
  3637. else {
  3638. r_result.type = ScriptLanguage::LOOKUP_RESULT_CLASS_CONSTANT;
  3639. r_result.class_name = "@GlobalScope";
  3640. r_result.class_member = p_symbol;
  3641. return OK;
  3642. }*/
  3643. r_result.type = ScriptLanguage::LOOKUP_RESULT_CLASS_TBD_GLOBALSCOPE;
  3644. r_result.class_name = "@GlobalScope";
  3645. r_result.class_member = p_symbol;
  3646. return OK;
  3647. }
  3648. } else {
  3649. List<StringName> utility_functions;
  3650. Variant::get_utility_function_list(&utility_functions);
  3651. if (utility_functions.find(p_symbol) != nullptr) {
  3652. r_result.type = ScriptLanguage::LOOKUP_RESULT_CLASS_TBD_GLOBALSCOPE;
  3653. r_result.class_name = "@GlobalScope";
  3654. r_result.class_member = p_symbol;
  3655. return OK;
  3656. }
  3657. }
  3658. }
  3659. } break;
  3660. case GDScriptParser::COMPLETION_ATTRIBUTE_METHOD: {
  3661. is_function = true;
  3662. [[fallthrough]];
  3663. }
  3664. case GDScriptParser::COMPLETION_ATTRIBUTE: {
  3665. if (context.node->type != GDScriptParser::Node::SUBSCRIPT) {
  3666. break;
  3667. }
  3668. const GDScriptParser::SubscriptNode *subscript = static_cast<const GDScriptParser::SubscriptNode *>(context.node);
  3669. if (!subscript->is_attribute) {
  3670. break;
  3671. }
  3672. GDScriptCompletionIdentifier base;
  3673. bool found_type = _get_subscript_type(context, subscript, base.type);
  3674. if (!found_type && !_guess_expression_type(context, subscript->base, base)) {
  3675. break;
  3676. }
  3677. if (_lookup_symbol_from_base(base.type, p_symbol, is_function, r_result) == OK) {
  3678. return OK;
  3679. }
  3680. } break;
  3681. case GDScriptParser::COMPLETION_TYPE_ATTRIBUTE: {
  3682. if (context.node == nullptr || context.node->type != GDScriptParser::Node::TYPE) {
  3683. break;
  3684. }
  3685. const GDScriptParser::TypeNode *type = static_cast<const GDScriptParser::TypeNode *>(context.node);
  3686. GDScriptParser::DataType base_type;
  3687. const GDScriptParser::IdentifierNode *prev = nullptr;
  3688. for (const GDScriptParser::IdentifierNode *E : type->type_chain) {
  3689. if (E->name == p_symbol && prev != nullptr) {
  3690. base_type = prev->get_datatype();
  3691. break;
  3692. }
  3693. prev = E;
  3694. }
  3695. if (base_type.kind != GDScriptParser::DataType::CLASS) {
  3696. GDScriptCompletionIdentifier base;
  3697. if (!_guess_expression_type(context, prev, base)) {
  3698. break;
  3699. }
  3700. base_type = base.type;
  3701. }
  3702. if (_lookup_symbol_from_base(base_type, p_symbol, is_function, r_result) == OK) {
  3703. return OK;
  3704. }
  3705. } break;
  3706. case GDScriptParser::COMPLETION_OVERRIDE_METHOD: {
  3707. GDScriptParser::DataType base_type = context.current_class->base_type;
  3708. if (_lookup_symbol_from_base(base_type, p_symbol, true, r_result) == OK) {
  3709. return OK;
  3710. }
  3711. } break;
  3712. case GDScriptParser::COMPLETION_PROPERTY_DECLARATION_OR_TYPE:
  3713. case GDScriptParser::COMPLETION_TYPE_NAME_OR_VOID:
  3714. case GDScriptParser::COMPLETION_TYPE_NAME: {
  3715. GDScriptParser::DataType base_type = context.current_class->get_datatype();
  3716. if (_lookup_symbol_from_base(base_type, p_symbol, false, r_result) == OK) {
  3717. return OK;
  3718. }
  3719. } break;
  3720. case GDScriptParser::COMPLETION_ANNOTATION: {
  3721. const String annotation_symbol = "@" + p_symbol;
  3722. if (parser.annotation_exists(annotation_symbol)) {
  3723. r_result.type = ScriptLanguage::LOOKUP_RESULT_CLASS_ANNOTATION;
  3724. r_result.class_name = "@GDScript";
  3725. r_result.class_member = annotation_symbol;
  3726. return OK;
  3727. }
  3728. } break;
  3729. default: {
  3730. }
  3731. }
  3732. return ERR_CANT_RESOLVE;
  3733. }
  3734. #endif // TOOLS_ENABLED