Prevent re-entrant script class update mutation

[dsarno]

Problem

This is related to the Task 'update_scripts_classes' already exists symptom reported in godotengine#115460, but fixes the issue from the EditorFileSystem side. It does not change ProgressDialog behavior globally.

This was found while developing and stress testing godot-ai, which exercises editor automation paths that repeatedly update tool scripts during editor startup. The minimal repro reduces that workload to a small @tool script that calls EditorFileSystem.update_file() during editor processing:

https://github.com/dsarno/godot-115460-gdscript-repro

EditorFileSystem::_update_script_classes() and _update_script_documentation() create EditorProgress tasks when more than one script is pending. In the GUI editor, EditorProgress can pump Main::iteration() through ProgressDialog::_update_ui().

That nested editor frame can run @tool script code and recursively enter pending script update processing while the outer pass is still active. For script class updates, this lets an inner _update_script_classes() mutate or clear update_script_paths while an outer _update_script_classes() range loop is still iterating it.

The crash can surface later while registering/removing global classes, but the corrupting invariant is the re-entrant mutation of the live pending container. The same re-entry path can also duplicate the documentation progress task.

Fix

• Move-drain update_script_paths into a local HashMap before creating EditorProgress or iterating script class updates.
• Move-drain update_script_paths_documentation into a local HashSet before creating its progress task.
• Add an _process_update_pending() re-entry guard with a pending-rerun bit, so updates queued by nested editor frames are preserved for a later pass instead of being processed recursively.
• Route the pre-reimport script class update path through the same guard while preserving the existing class-before-documentation ordering.

If a tool script continuously queues new script class updates during every pumped editor frame, documentation updates can still be delayed until that update stream settles. This PR keeps the fix scoped to pending script update processing instead of changing progress dialog behavior globally.

Testing

Built locally:

scons platform=macos target=editor dev_build=yes arch=arm64 vulkan=no tests=yes -j8

Focused doctest suites:

bin/godot.macos.editor.dev.arm64 --headless --test --test-suite='*[GDScript]*,*[Editor]*'

Result: 6 test cases passed, 58,688 assertions passed.

Regression repro verification with the MRP linked above:

• GENERATED_SCRIPT_COUNT := 2, MAX_TICKS := 80: finished without crash, no duplicate update_scripts_classes, no duplicate update_script_paths_documentation, no !tasks.has assertion.
• GENERATED_SCRIPT_COUNT := 2, MAX_TICKS := 0: smooth editor load, finished without crash, max_re_entry=1.
• GENERATED_SCRIPT_COUNT := 1, headless control: finished without crash, max_re_entry=1.

No automated regression test is included because the proven failure mechanism requires GUI ProgressDialog pumping Main::iteration() during editor filesystem processing. The current headless doctest harness does not directly exercise that GUI progress re-entry path without a synthetic editor integration harness.

[Copilot]

Pull request overview

This PR fixes a crash class of re-entrant mutations in EditorFileSystem pending script update containers by preventing recursive processing while an outer update pass is still iterating, which can occur when EditorProgress pumps Main::iteration() via the editor UI.

Changes:

• Drain update_script_paths / update_script_paths_documentation into local containers before creating EditorProgress and iterating, preventing re-entrant mutation of the live pending containers.
• Add _process_update_pending() re-entry guarding with a queued-rerun mechanism to defer nested update requests to a later pass instead of recursing.
• Route the pre-reimport “update script classes first” path through the same guarded mechanism while preserving ordering.

Reviewed changes

Copilot reviewed 2 out of 2 changed files in this pull request and generated 1 comment.

File	Description
editor/file_system/editor_file_system.h	Adds re-entry guard state and updates _process_update_pending signature to support class-only processing.
editor/file_system/editor_file_system.cpp	Drains pending containers before iteration and introduces guarded, rerunnable pending-update processing to prevent re-entrant mutation crashes.

Comments suppressed due to low confidence (1)

editor/file_system/editor_file_system.cpp:2217

• Similar to the script class updates, script_paths_to_update_documentation = update_script_paths_documentation; update_script_paths_documentation.clear(); copies the whole HashSet and then clears the original. If this set can get large, consider draining it via move/swap under the mutex to avoid O(n) copying/allocation churn (HashSet has move assignment available in core/templates/hash_set.h).

	HashSet<String> script_paths_to_update_documentation;
	{
		MutexLock update_script_lock(update_script_mutex);
		script_paths_to_update_documentation = update_script_paths_documentation;
		update_script_paths_documentation.clear();
	}

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.