Add a dedicated function that runs in editor for every script without the need to declare the entire script as @tool.

[darth-biomech]

Describe the project you are working on

A point-and-click sci-fi 3D quest with VN elements.

Describe the problem or limitation you are having in your project

I come from Unity, and then you could do what Godot has with @tool, by adding [ExecuteInEditor] flare to a class you make it... well, execute in the editor. However, it seems that Godot lacks a function that would be analogous to Unity's OnValidate() - it runs only in the editor, and is called each time one of the variables got changed. It is very handy to level design-oriented set up, like auto-assigning models and textures to a mesh, or establishing references.

As I've learned in this issue comment, you can't call non-tool functions, so my attempt on emulating OnValidate() with the following script attached to the scene root has failed.

@tool
extends Node3D

func _process(delta):
	if Engine.is_editor_hint():		
		for i in self.get_children():
			if i.has_method("_editor_on_change"):
				i._editor_on_change()

Judging by what is written in the help about the @tool and the very name itself, it is not designed to be used for anything except writing tools for extending the editor functionality.

Describe the feature / enhancement and how it helps to overcome the problem or limitation

The fact that @tool makes the entire script to be runnable by the editor makes it extremely dangerous to mishandle, it didn't took long for somebody on the Godot's Discord to share that using it bricked their entire project.
By having a dedicated function designed to be called in editor only on specific events, unintentional breakage can be avoided, especially if there will be some additional safeguards around it.

Describe how your proposal will work, with code, pseudo-code, mock-ups, and/or diagrams

If user includes this function in their script

	extends CollisionShape3D
	@export_file("*.obj") var item_model
	@export var collision_size:Vector3 = Vector3.ONE

	func _editor_on_change():
		$CollisionShape3D.shape.size = collision_size
		if $MeshInstance3D.mesh.resource.path != null && $MeshInstance3D.mesh.resource.path != item_model && item_model != null:
			$MeshInstance3D.mesh = load(item_model)
		$CollisionShape3D.shape.size = collision_size

it should be called each time any of the exported variables change, and the relevant node's parameters would be updated in almost-realtime, in this example - changing the size of the collision box and changing the model on a node assembly of an ingame item template.

If this enhancement will not be used often, can it be worked around with a few lines of script?

Yes.

Is there a reason why this should be core and not an add-on in the asset library?

Ability to set up game objects in the editor and immediately seeing what is the result of your changes without the need to start the game is a very important QOL feature.
At the same time, using @tool like was suggested to me on the Discord server seems like an unsafe hack around the problem with function intended for other purpose rather than a proper solution, since you need to take additional steps to ensure that your game code and editor code wouldn't be executed together (adding largely unnecessary if checks to everything, etc). Having a separate function would've made things A LOT easier and straightforward.

[YuriSizov]

The title of your proposal is very vague, but from the description I believe what you want is #7029 / #729. So I'm going to close this as a duplicate of those discussions.

Note that the tool annotation/keyword serves as a hint to load the script in the editor. Without it the script will not be loaded at all, so you can't have a method that runs in the editor without this hint. (And it's called tool because the editor is historically referred to as a tools build in the engine source).

---

Regarding reacting to every property change, we don't have an observer pattern. You need to define setters for each property or use _set, depending on how you want it to work.