Generate engine API suggestions header from Lua bindings and C++ headers

Author: eduardodoria

CMakeLists.txt

@@ -41,6 +41,7 @@ set(EDITOR_DIR editor)
 # Find OpenGL
 find_package(OpenGL REQUIRED)
 find_package(Threads REQUIRED)
+find_package(Python3 REQUIRED COMPONENTS Interpreter)
 
 set(BACKEND_SOURCES)
 set(BACKEND_LIBS)
@@ -106,6 +107,24 @@ add_custom_command(
     WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
 )
 
+# Generate engine API suggestions header from Lua bindings and C++ headers
+set(BINDING_DIR "${CMAKE_SOURCE_DIR}/engine/core/script/binding")
+set(ENGINE_CORE_DIR "${CMAKE_SOURCE_DIR}/engine/core")
+set(API_SUGGESTIONS_HEADER "${GENERATED_DIR}/engine_api_suggestions.h")
+set(GENERATE_API_SCRIPT "${CMAKE_SOURCE_DIR}/generate_api_suggestions.py")
+
+file(GLOB BINDING_FILES "${BINDING_DIR}/*.cpp")
+file(GLOB_RECURSE ENGINE_HEADERS "${ENGINE_CORE_DIR}/*.h")
+
+add_custom_command(
+    OUTPUT ${API_SUGGESTIONS_HEADER}
+    COMMAND ${Python3_EXECUTABLE} ${GENERATE_API_SCRIPT}
+            ${BINDING_DIR} ${API_SUGGESTIONS_HEADER} ${ENGINE_CORE_DIR}
+    DEPENDS ${GENERATE_API_SCRIPT} ${BINDING_FILES} ${ENGINE_HEADERS}
+    COMMENT "Generating engine_api_suggestions.h from Lua bindings and C++ headers"
+    WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
+)
+
 include_directories (${CMAKE_CURRENT_SOURCE_DIR})
 
 include_directories (${DORIAX_ROOT}/libs/sokol)
@@ -164,6 +183,7 @@ if(UNIX AND NOT APPLE)
 endif()
 
 add_custom_target(generate_shaders DEPENDS ${SHADERS_HEADER})
+add_custom_target(generate_api_suggestions DEPENDS ${API_SUGGESTIONS_HEADER})
 
 add_executable(
     doriax-editor
@@ -259,7 +279,7 @@ add_executable(
     ${BACKEND_SOURCES}
 )
 
-add_dependencies(doriax-editor generate_shaders)
+add_dependencies(doriax-editor generate_shaders generate_api_suggestions)
 
 # Include directories
 target_include_directories(doriax-editor PRIVATE

editor/window/CodeEditor.cpp

@@ -41,11 +41,23 @@ namespace doriax::editor {
         bool windowFocused;
         EditorInstance* lastFocused;
 
+        std::thread symbolParseThread;
+        std::atomic<bool> isParsingSymbols{false};
+        std::mutex parsedSymbolsMutex;
+        std::vector<CustomTextEditor::ProjectSymbol> newLuaSymbols;
+        std::vector<CustomTextEditor::ProjectSymbol> newCppSymbols;
+        std::atomic<bool> newSymbolsReady{false};
+
         void checkFileChanges(EditorInstance& instance);
         bool loadFileContent(EditorInstance& instance);
         void handleFileChangePopup();
         std::string getWindowTitle(const EditorInstance& instance) const;
         void updateScriptProperties(const EditorInstance& instance, const std::string& inMemoryContent = "");
+
+        // Background parsing for project symbols
+        void updateAllProjectSymbols();
+        void applyParsedProjectSymbols();
+
         fs::path resolveFilepath(const fs::path& relPath) const;
         std::string toRelativePath(const std::string& filepath) const;
         void insertLuaEntityProperty(EditorInstance& instance, Entity entity, uint32_t entitySceneId);

editor/window/CodeEditor.h

@@ -1,5 +1,6 @@
 #include "CustomTextEditor.h"
 #include "SemanticSuggestions.h"
+#include "engine_api_suggestions.h"
 #include "external/IconsFontAwesome6.h"
 #include "util/UIUtils.h"
 #include "App.h"
@@ -10,6 +11,7 @@
 #include <numeric>
 #include <sstream>
 #include <cstring>
+#include <regex>
 
 #ifdef _WIN32
 #include <Windows.h>
@@ -118,10 +120,10 @@ void CustomTextEditor::initializeLanguage() {
                 "string", "vector", "map", "unordered_map", "set", "unordered_set",
                 "array", "list", "deque", "queue", "stack", "pair", "tuple",
                 "unique_ptr", "shared_ptr", "weak_ptr",
-                "function", "optional", "variant", "any",
-                "Entity", "Scene", "Transform", "Vector2", "Vector3", "Vector4",
-                "Matrix4", "Quaternion", "Color", "Rect"
+                "function", "optional", "variant", "any"
             };
+            // Add engine types from auto-generated header
+            for (const auto& t : getEngineTypeNames()) languageDef.types.insert(t);
             languageDef.singleLineComment = "//";
             languageDef.multiLineCommentStart = "/*";
             languageDef.multiLineCommentEnd = "*/";
@@ -138,13 +140,18 @@ void CustomTextEditor::initializeLanguage() {
                 "string", "number", "boolean", "table", "function", "thread",
                 "userdata"
             };
+            // Add engine types from auto-generated header
+            for (const auto& t : getEngineTypeNames()) languageDef.types.insert(t);
             languageDef.builtinFunctions = {
                 "assert", "collectgarbage", "dofile", "error", "getmetatable",
                 "ipairs", "load", "loadfile", "next", "pairs", "pcall", "print",
                 "rawequal", "rawget", "rawlen", "rawset", "require", "select",
                 "setmetatable", "tonumber", "tostring", "type", "xpcall",
                 "coroutine", "debug", "io", "math", "os", "package", "string", "table", "utf8"
             };
+            // Add engine builtins (static classes + enums) from auto-generated header
+            for (const auto& b : getEngineBuiltinNames()) languageDef.builtinFunctions.insert(b);
+            for (const auto& e : getEngineEnumNames()) languageDef.builtinFunctions.insert(e);
             languageDef.singleLineComment = "--";
             languageDef.multiLineCommentStart = "--[[";
             languageDef.multiLineCommentEnd = "]]";
@@ -277,6 +284,48 @@ void CustomTextEditor::initializeSuggestions() {
         suggestions->AddSnippet("cmake_min", "cmake_minimum_required(VERSION ${1:3.16})", "cmake minimum version");
         suggestions->AddSnippet("project", "project(${1:name}\n\tVERSION ${2:1.0.0}\n\tLANGUAGES ${3:CXX}\n)", "project definition");
     }
+
+    // Add engine API suggestions for Lua and C++
+    if (language == SyntaxLanguage::Lua || language == SyntaxLanguage::Cpp) {
+        addEngineAPISuggestions();
+    }
+}
+
+void CustomTextEditor::addEngineAPISuggestions() {
+    if (!suggestions) return;
+
+    static const auto& apiSymbols = getEngineAPISymbols();
+
+    static const std::unordered_map<std::string, SuggestionKind> kindMap = {
+        {"Class", SuggestionKind::Class},
+        {"Enum", SuggestionKind::Enum},
+        {"EnumMember", SuggestionKind::EnumMember},
+        {"Method", SuggestionKind::Method},
+        {"Function", SuggestionKind::Function},
+        {"Property", SuggestionKind::Property},
+        {"Constant", SuggestionKind::Constant},
+        {"Variable", SuggestionKind::Variable},
+    };
+
+    for (const auto& sym : apiSymbols) {
+        SuggestionKind sk = SuggestionKind::Variable;
+        auto it = kindMap.find(sym.kind);
+        if (it != kindMap.end()) sk = it->second;
+        suggestions->AddSymbol(sym.name, sk, sym.detail, sym.parent ? sym.parent : "");
+
+        // Build inheritance map from class detail strings like "class Mesh : Object"
+        if (sk == SuggestionKind::Class && sym.detail) {
+            std::string detail = sym.detail;
+            size_t colonPos = detail.find(" : ");
+            if (colonPos != std::string::npos) {
+                std::string className = sym.name;
+                std::string parentName = detail.substr(colonPos + 3);
+                // Trim any trailing whitespace
+                while (!parentName.empty() && parentName.back() == ' ') parentName.pop_back();
+                suggestions->SetClassParent(className, parentName);
+            }
+        }
+    }
 }
 
 void CustomTextEditor::SetLanguage(SyntaxLanguage lang) {
@@ -1756,11 +1805,61 @@ char CustomTextEditor::findMatchingBracket(const TextPosition& pos, TextPosition
     return target;
 }
 
+std::string CustomTextEditor::inferTypeOfVariable(const std::string& varName, int currentLine) const {
+    if (varName.empty()) return "";
+
+    // C++ patterns:
+    // 1. Standard declaration: [const] Type [*&] varName
+    std::regex cppDeclRegex("(?:const\\s+)?([A-Za-z0-9_:]+)(?:<[^>]*>)?\\s*(?:[*&]+\\s*)?" + varName + "\\b");
+    // 2. auto varName = new Type(...)
+    std::regex cppNewRegex("\\bauto\\s*[*&]*\\s*" + varName + "\\s*=\\s*new\\s+([A-Za-z0-9_:]+)");
+    // 3. auto varName = Type(...)  or  auto varName = Type{...}
+    std::regex cppAutoCtorRegex("\\bauto\\s*[*&]*\\s*" + varName + "\\s*=\\s*([A-Z][A-Za-z0-9_:]*)\\s*[({]");
+
+    std::regex luaVarRegex("\\b" + varName + "\\s*=\\s*([A-Za-z0-9_\\.:]+)(?:\\(|\\{)");
+    std::regex luaLocalVarRegex("\\blocal\\s+" + varName + "\\s*=\\s*([A-Za-z0-9_\\.:]+)(?:\\(|\\{)");
+
+    // Search backwards from the current line
+    for (int i = currentLine; i >= 0; --i) {
+        if (i >= static_cast<int>(lines.size())) continue;
+        const std::string& line = lines[i];
+        std::smatch match;
+
+        if (language == SyntaxLanguage::Cpp) {
+            // Try auto = new Type first (most specific)
+            if (std::regex_search(line, match, cppNewRegex)) {
+                return match[1].str();
+            }
+            // Try auto = Type() / Type{}
+            if (std::regex_search(line, match, cppAutoCtorRegex)) {
+                return match[1].str();
+            }
+            // Try standard declaration
+            if (std::regex_search(line, match, cppDeclRegex)) {
+                std::string typeMatch = match[1].str();
+                if (typeMatch != "return" && typeMatch != "new" && typeMatch != "delete" && typeMatch != "auto") {
+                    return typeMatch;
+                }
+            }
+        } else if (language == SyntaxLanguage::Lua) {
+            if (std::regex_search(line, match, luaLocalVarRegex)) {
+                return match[1].str();
+            }
+            if (std::regex_search(line, match, luaVarRegex)) {
+                return match[1].str();
+            }
+        }
+    }
+    return "";
+}
+
 SuggestionContext CustomTextEditor::buildSuggestionContext() const {
     SuggestionContext ctx;
 
     if (cursors.empty()) return ctx;
 
+    ctx.isCpp = (language == SyntaxLanguage::Cpp);
+
     const TextPosition& pos = cursors[primaryCursor].position;
 
     // Get current word being typed
@@ -1784,22 +1883,52 @@ SuggestionContext CustomTextEditor::buildSuggestionContext() const {
                 ctx.afterDot = true;
             } else if (c == '>' && checkCol > 0 && ctx.lineContent[checkCol - 1] == '-') {
                 ctx.afterArrow = true;
+                checkCol--; // move past '-'
             } else if (c == ':' && checkCol > 0 && ctx.lineContent[checkCol - 1] == ':') {
                 ctx.afterDoubleColon = true;
+                checkCol--; // move past first ':'
+            } else if (c == ':') {
+                if (language == SyntaxLanguage::Lua) {
+                    ctx.afterColon = true;
+                }
             }
         }
     }
 
-    // Get previous word for context
-    if (wordStart.column > 1) {
-        TextPosition prevEnd(pos.line, wordStart.column - 1);
-        // Skip whitespace
-        while (prevEnd.column > 0 && std::isspace(ctx.lineContent[prevEnd.column - 1])) {
+    // Get previous word for context (e.g. before the dot)
+    if (checkCol > 0) {
+        TextPosition prevEnd(pos.line, checkCol - 1);
+        // Skip whitespace if any
+        while (prevEnd.column > 0 && std::isspace(ctx.lineContent[prevEnd.column])) {
             prevEnd.column--;
         }
-        if (prevEnd.column > 0) {
-            TextPosition prevStart = findWordStart(prevEnd);
-            ctx.previousWord = getRange(prevStart, prevEnd);
+        if (prevEnd.column >= 0 && (std::isalnum(ctx.lineContent[prevEnd.column]) || ctx.lineContent[prevEnd.column] == '_')) {
+            TextPosition prevStart = findWordStart(TextPosition(pos.line, prevEnd.column + 1));
+            // getRange uses end column generically as exclusive bound, so we use prevEnd.column+1
+            ctx.previousWord = getRange(prevStart, TextPosition(pos.line, prevEnd.column + 1));
+        }
+    }
+
+    // Infer the type of the previous word for semantic suggestions
+    if (ctx.afterDot || ctx.afterArrow || ctx.afterDoubleColon || ctx.afterColon) {
+        if (!ctx.previousWord.empty()) {
+            if (ctx.afterDoubleColon) {
+                // For ::, the previousWord IS the type name (e.g. Vector3::ZERO)
+                ctx.targetType = ctx.previousWord;
+            } else {
+                ctx.targetType = inferTypeOfVariable(ctx.previousWord, pos.line);
+                // Fallback: look up the variable in project symbols (e.g. header member variables)
+                if (ctx.targetType.empty() && suggestions) {
+                    ctx.targetType = suggestions->FindSymbolType(ctx.previousWord);
+                }
+            }
+            // Strip namespace prefix for matching engine API parent types (e.g. "doriax::Mesh" -> "Mesh")
+            if (!ctx.targetType.empty()) {
+                size_t lastColon = ctx.targetType.rfind(':');
+                if (lastColon != std::string::npos) {
+                    ctx.targetType = ctx.targetType.substr(lastColon + 1);
+                }
+            }
         }
     }
 
@@ -1821,6 +1950,23 @@ void CustomTextEditor::CloseAutoComplete() {
     autoCompleteItems.clear();
 }
 
+void CustomTextEditor::UpdateProjectSymbols(const std::vector<ProjectSymbol>& symbols) {
+    if (!suggestions) return;
+
+    suggestions->ClearSymbols();
+    suggestions->ClearInheritance();
+
+    // Re-add engine API symbols
+    if (language == SyntaxLanguage::Lua || language == SyntaxLanguage::Cpp) {
+        addEngineAPISuggestions();
+    }
+
+    // Add pre-parsed project symbols
+    for (const auto& sym : symbols) {
+        suggestions->AddSymbol(sym.name, static_cast<SuggestionKind>(sym.kind), sym.detail, sym.parentType, sym.typeInfo);
+    }
+}
+
 void CustomTextEditor::updateSuggestions() {
     if (!suggestions) return;
 
@@ -2715,7 +2861,21 @@ void CustomTextEditor::handleTextInput() {
                 }
 
                 // Update auto-complete
-                if (autoComplete && std::isalnum(c)) {
+                bool shouldTrigger = false;
+                if (autoComplete) {
+                    if (std::isalnum(c) || c == '_' || c == '.' || c == ':') {
+                        shouldTrigger = true;
+                    } else if (c == '>' && language == SyntaxLanguage::Cpp) {
+                        // Trigger for '->' operator
+                        const auto& pos = cursors[primaryCursor].position;
+                        if (pos.column >= 2 && pos.line < static_cast<int>(lines.size())) {
+                            if (lines[pos.line][pos.column - 2] == '-') {
+                                shouldTrigger = true;
+                            }
+                        }
+                    }
+                }
+                if (shouldTrigger) {
                     TriggerAutoComplete();
                 } else if (showAutoComplete) {
                     // Close autocomplete when typing non-identifier characters
@@ -3172,6 +3332,12 @@ void CustomTextEditor::Render(const char* title, const ImVec2& size, bool border
     if (contentSize.y == 0) contentSize.y = ImGui::GetContentRegionAvail().y;
 
     if (ImGui::BeginChild(title, contentSize, border ? ImGuiChildFlags_Borders : ImGuiChildFlags_None, flags)) {
+        // Auto-focus editor child when parent window is focused but child is not
+        // (e.g., user clicked the window tab/title bar)
+        if (!ImGui::IsWindowFocused() && ImGui::IsWindowFocused(ImGuiFocusedFlags_RootAndChildWindows)) {
+            ImGui::SetWindowFocus();
+        }
+
         if (pendingFocus) {
             ImGui::SetWindowFocus();
             pendingFocus = false;

editor/window/widget/CustomTextEditor.cpp

@@ -200,6 +200,17 @@ namespace doriax::editor {
         void CloseAutoComplete();
         bool IsAutoCompleteOpen() const { return showAutoComplete; }
 
+        struct ProjectSymbol {
+            std::string name;
+            int kind; // SuggestionKind cast to int
+            std::string detail;
+            std::string parentType; // Class/type this belongs to (if any)
+            std::string typeInfo;   // Declared type (for member variables, e.g. "Mesh" for "Mesh* box4")
+        };
+
+        // Project symbols (scanned from sibling files at runtime)
+        void UpdateProjectSymbols(const std::vector<ProjectSymbol>& symbols);
+
         // Tooltip
         void ShowTooltip(const std::string& text, const ImVec2& pos);
         void HideTooltip();
@@ -309,10 +320,12 @@ namespace doriax::editor {
         void initializeLanguage();
         void initializePalette();
         void initializeSuggestions();
+        void addEngineAPISuggestions();
         void updateSuggestions();
         void applySuggestion();
         void renderSuggestions(const ImVec2& origin);
         SuggestionContext buildSuggestionContext() const;
+        std::string inferTypeOfVariable(const std::string& varName, int currentLine) const;
         void tokenizeLine(int lineIndex);
         void tokenizeAll();
         TokenType classifyWord(const std::string& word) const;