gdharness 1.3.3 → 1.3.4

package/build/godot/addons/gdharness_editor/declared_values.gd

@@ -58,12 +58,46 @@ static func enum_named(choices: Dictionary, word: String) -> Variant:
 	return null
 
 
-static func enum_refusal(holder: String, property: String, word: String, choices: Dictionary) -> String:
+## The values of the engine enum [param property] of [param target] holds, by the constants its
+## class declares them as: blend_mode's Add is BLEND_MODE_ADD in a script, and the hint gives only
+## the inspector's word. Empty for an enum a script declares.
+##
+## The enum is named by the setter's argument, as Node.ProcessMode, since the property list gives
+## an engine enum property no class of its own.
+static func engine_constants(target: Object, property: String) -> Dictionary:
+	var values: Dictionary = {}
+	var engine_class: String = target.get_class()
+	var setter: String = str(ClassDB.class_get_property_setter(engine_class, property))
+	if setter.is_empty():
+		return values
+	var named: String = ""
+	for method: Dictionary in ClassDB.class_get_method_list(engine_class):
+		var arguments: Array = method.get("args", [])
+		if str(method.get("name", "")) == setter and not arguments.is_empty():
+			var value_argument: Dictionary = arguments[-1]
+			named = str(value_argument.get("class_name", ""))
+			break
+	var holder: String = named.get_slice(".", 0)
+	if named.count(".") != 1 or not ClassDB.class_exists(holder):
+		return values
+	for constant: String in ClassDB.class_get_enum_constants(holder, named.get_slice(".", 1)):
+		values[constant] = ClassDB.class_get_integer_constant(holder, constant)
+	return values
+
+
+static func enum_refusal(
+	holder: String, property: String, word: String, choices: Dictionary, constants: Dictionary = {}
+) -> String:
+	var ways: String = "by name or by number"
+	if not constants.is_empty():
+		ways = "by name, by number or by the engine's constant, such as %s" % str(constants.keys()[0])
 	var said: String = (
-		"%s.%s is an enum, and %s is none of its values: send %s by name or by number"
-		% [holder, property, word, _listed(choices)]
+		"%s.%s is an enum, and %s is none of its values: send %s %s"
+		% [holder, property, word, _listed(choices), ways]
 	)
-	var close: PackedStringArray = GdhRead.nearest(word, PackedStringArray(choices.keys()))
+	var named: PackedStringArray = PackedStringArray(choices.keys())
+	named.append_array(PackedStringArray(constants.keys()))
+	var close: PackedStringArray = GdhRead.nearest(word, named)
 	if close.is_empty():
 		return said + "."
 	return said + ". The nearest %s %s." % ["is" if close.size() == 1 else "are", ", ".join(close)]
@@ -76,6 +110,17 @@ static func outside(target: Object, declared: Dictionary, value: Variant, shown:
 	var hint: int = GdhRead.as_int(declared.get("hint", PROPERTY_HINT_NONE))
 	var hint_string: String = str(declared.get("hint_string", ""))
 	var property: String = str(declared.get("name", ""))
+	if hint == PROPERTY_HINT_ENUM and (typeof(value) == TYPE_STRING or typeof(value) == TYPE_STRING_NAME):
+		var names: PackedStringArray = PackedStringArray(enum_values(hint_string).keys())
+		if names.is_empty() or names.has(str(value)):
+			return ""
+		return (
+			(
+				"%s is none of the names %s lists: %s, which the inspector holds it to; the engine "
+				+ "stores it as given."
+			)
+			% [shown, property, ", ".join(names)]
+		)
 	if typeof(value) != TYPE_INT and typeof(value) != TYPE_FLOAT:
 		return ""
 	var number: float = GdhRead.as_float(value)
@@ -114,3 +159,111 @@ static func _listed(choices: Dictionary) -> String:
 ## A range's end as the script wrote it: the engine's hint gives @export_range(0, 10) as 0.0 and 10.0.
 static func _bound(end: float) -> String:
 	return str(int(end)) if end == floorf(end) and absf(end) < 1e15 else str(end)
+
+
+## Puts back on [param built] what its script set as it was attached and was not among
+## [param wanted], to the defaults it declares, outside the editor. Attaching runs the script's _init
+## there, which the editor never runs for a script that is not a tool, so a resource_name _init chose
+## was saved as if asked for. A property whose default the engine cannot report is left as made.
+static func unmade(built: Resource, wanted: Dictionary) -> void:
+	var attached: Variant = built.get_script()
+	if Engine.is_editor_hint() or not attached is Script:
+		return
+	var script: Script = attached
+	var asked: Dictionary = {}
+	for key: Variant in wanted:
+		asked[str(key).get_slice(":", 0)] = true
+	for entry: Dictionary in built.get_property_list():
+		var name: String = str(entry["name"])
+		var usage: int = GdhRead.as_int(entry["usage"])
+		if usage & PROPERTY_USAGE_STORAGE == 0 or name == "script" or asked.has(name):
+			continue
+		var declared: Variant = ClassDB.class_get_property_default_value(built.get_class(), name)
+		if usage & PROPERTY_USAGE_SCRIPT_VARIABLE:
+			declared = script.get_property_default_value(name)
+		var held: Variant = built.get(name)
+		if declared != null and not (typeof(held) == typeof(declared) and held == declared):
+			built.set(name, declared)
+
+
+## The element types a typed Array or Dictionary property declares: [element] for an array,
+## [key, value] for a dictionary, [] when nothing is declared.
+##
+## Read from the declaration because the value cannot say: a script's exported `Array[int]` sits
+## behind a placeholder in the editor, and measured on 4.7.2 that placeholder stores [1.5, 2.0]
+## as given, which the game then fails to load into the typed array.
+static func elements_of(declared: Dictionary) -> Array:
+	var type: int = GdhRead.as_int(declared.get("type", TYPE_NIL), TYPE_NIL)
+	var hint: int = GdhRead.as_int(declared.get("hint", PROPERTY_HINT_NONE))
+	var wanted: String = str(declared.get("hint_string", ""))
+	if wanted.is_empty():
+		return []
+	if hint == PROPERTY_HINT_TYPE_STRING:
+		var parts: PackedStringArray = wanted.split(";")
+		if type == TYPE_ARRAY and parts.size() == 1:
+			return [_type_in_hint(parts[0])]
+		if type == TYPE_DICTIONARY and parts.size() == 2:
+			return [_type_in_hint(parts[0]), _type_in_hint(parts[1])]
+		return []
+	if hint == PROPERTY_HINT_ARRAY_TYPE and type == TYPE_ARRAY:
+		return [_type_named(wanted)]
+	if hint == PROPERTY_HINT_DICTIONARY_TYPE and type == TYPE_DICTIONARY:
+		var parts: PackedStringArray = wanted.split(";")
+		if parts.size() == 2:
+			return [_type_named(parts[0]), _type_named(parts[1])]
+	return []
+
+
+## The type at the front of one entry of a type-string hint, "2:" or "24/17:Texture2D".
+static func _type_in_hint(entry: String) -> int:
+	var number: String = entry.get_slice(":", 0).get_slice("/", 0)
+	return number.to_int() if number.is_valid_int() else TYPE_NIL
+
+
+## The Variant type [param name] names, or TYPE_OBJECT for a class.
+static func _type_named(name: String) -> int:
+	var named: String = name.get_slice(":", 0).strip_edges()
+	for type: int in TYPE_MAX:
+		if type_string(type) == named:
+			return type
+	return TYPE_OBJECT if not named.is_empty() else TYPE_NIL
+
+
+## The class the objects of a typed list or map hold, and whether they are nodes, as
+## [class, nodes], read from entry [param at] of [param declared]'s hint: "24/17:Item" in a type
+## string, "Item" in an array or dictionary type.
+static func object_kind(declared: Dictionary, at: int) -> Array:
+	var entry: String = str(declared.get("hint_string", "")).get_slice(";", at)
+	if GdhRead.as_int(declared.get("hint", PROPERTY_HINT_NONE)) != PROPERTY_HINT_TYPE_STRING:
+		return [entry.strip_edges(), false]
+	var nodes: bool = entry.get_slice(":", 0).get_slice("/", 1) == str(PROPERTY_HINT_NODE_TYPE)
+	return [entry.get_slice(":", 1), nodes]
+
+
+## The base class and script that type a list or map holding [param wanted], as [class, script],
+## or [] when nothing in the project or the engine is called that.
+static func object_typing(wanted: String) -> Array:
+	if ClassDB.class_exists(wanted):
+		return [StringName(wanted), null]
+	var script: Script = script_class(wanted)
+	return [] if script == null else [script.get_instance_base_type(), script]
+
+
+## The script declaring the class_name [param name], or null.
+static func script_class(name: String) -> Script:
+	for entry: Dictionary in ProjectSettings.get_global_class_list():
+		if str(entry.get("class", "")) == name:
+			return load(str(entry.get("path", ""))) as Script
+	return null
+
+
+## Whether [param value] is the class [param name] names, an engine class or a script's class_name.
+static func is_a(value: Object, name: String) -> bool:
+	if value.is_class(name):
+		return true
+	var script: Script = value.get_script()
+	while script != null:
+		if str(script.get_global_name()) == name:
+			return true
+		script = script.get_base_script()
+	return false

package/build/godot/addons/gdharness_editor/file_reads.gd

@@ -10,8 +10,8 @@ extends RefCounted
 ## without making a node. Loading the file still does what loading does in the game: static
 ## initialisers run, and a resource with a script is made with it.
 
-const GdhPropertyValues = preload("property_values.gd")
 const GdhRead = preload("reading.gd")
+const GdhSame = preload("same_values.gd")
 const GdhSerialisation = preload("serialisation.gd")
 
 
@@ -188,6 +188,12 @@ static func _lay(
 					path,
 					state.get_node_index(index)
 				)
+		# Every file on the way puts the node in its own groups: the scene making it, and each scene
+		# instancing or inheriting that one.
+		var grouped: Array[String] = nodes[path]["groups"]
+		for group: StringName in state.get_node_groups(index):
+			if not grouped.has(str(group)):
+				grouped.append(str(group))
 		var held: Dictionary = nodes[path]["properties"]
 		for property: int in state.get_node_property_count(index):
 			held[str(state.get_node_property_name(index, property))] = state.get_node_property_value(
@@ -281,7 +287,8 @@ static func _by_id(nodes: Dictionary, owner: String, id: int) -> String:
 
 static func _made(type: String) -> Dictionary:
 	var children: Array[String] = []
-	return {"name": "", "type": type, "properties": {}, "children": children}
+	var groups: Array[String] = []
+	return {"name": "", "type": type, "properties": {}, "children": children, "groups": groups}
 
 
 ## Puts [param path] among [param parent]'s children, at [param at] when the file says where (a node
@@ -317,6 +324,11 @@ static func _entry(
 		data["instanceOf"] = node["instanceOf"]
 		if node.has("editableChildren"):
 			data["editableChildren"] = node["editableChildren"]
+	var groups: Array[String] = node["groups"]
+	if not groups.is_empty():
+		var sorted: Array[String] = groups.duplicate()
+		sorted.sort()
+		data["groups"] = sorted
 	if include_properties:
 		var given: Dictionary = node["properties"]
 		data["properties"] = _stored(str(node["type"]), given)
@@ -419,7 +431,7 @@ static func resource(res_path: String, include_defaults: bool) -> Dictionary:
 				if scripted.has(property)
 				else ClassDB.class_get_property_default_value(loaded.get_class(), property)
 			)
-			if GdhPropertyValues.same(value, default):
+			if GdhSame.same(value, default):
 				continue
 		properties[property] = serialiser.serialize_value(value)
 	var answer: Dictionary = {

package/build/godot/addons/gdharness_editor/headless_check.gd

@@ -11,8 +11,9 @@ extends RefCounted
 ## both, so a property a built-in setter derives (a Control's offsets from its size) is left alone
 ## unless a script that is not a tool is involved.
 
-const GdhPropertyValues = preload("property_values.gd")
+const GdhPropertyPaths = preload("property_paths.gd")
 const GdhRead = preload("reading.gd")
+const GdhSame = preload("same_values.gd")
 
 const REMEDY: String = (
 	"Open the project's editor (editor_launch with hidden: true) and ask again: the write then goes "
@@ -78,7 +79,7 @@ static func differing(object: Object, before: Dictionary, names: Dictionary) ->
 		if names.has(name):
 			continue
 		var was: Variant = before[name] if before.has(name) else default_of(object, name)
-		if not GdhPropertyValues.same(now[name], was):
+		if not GdhSame.same(now[name], was):
 			changed.append(name)
 	return changed
 
@@ -122,28 +123,46 @@ static func _initialised(script: Script, name: String, type: int) -> Variant:
 ## nothing a script did: the saver writes a property whose default the engine cannot report whatever
 ## it holds, the editor's save as well.
 static func at_default(object: Object, name: String) -> bool:
-	return GdhPropertyValues.same(object.get(name), default_of(object, name))
+	return GdhSame.same(object.get(name), default_of(object, name))
 
 
-## The ids, in the file, of the embedded resources [param property] reaches into on [param object],
-## such as the material of [code]material:albedo_color[/code], as a set.
+## What [param property] writes in the embedded resource it reaches into on [param object], by its
+## id in the file, as the set of names written in it: the hp of the resource built in as inner for
+## [code]inner/hp[/code], or position for [code]inner/position:x[/code]. Only those names are spared
+## from the check for what a script changed: the resource's _init still ran when it was loaded, and
+## sparing the whole resource saved what that set.
 static func reached(object: Object, property: String) -> Dictionary:
 	var ids: Dictionary = {}
-	var parts: PackedStringArray = property.split(":")
-	var current: Variant = object
-	for index: int in parts.size() - 1:
-		if not current is Object:
-			break
-		var holder: Object = current
-		current = holder.get(parts[index])
-		if current is Resource:
-			var resource: Resource = current
-			var id: String = resource.get_scene_unique_id()
-			if not id.is_empty():
-				ids[id] = true
+	var place: Array = GdhPropertyPaths.holder_of(object, property)
+	var through: Array[Resource] = place[2]
+	if through.is_empty():
+		return ids
+	var holder: Resource = through.back()
+	var name: String = place[1]
+	if GdhPropertyPaths.declared_on(holder, name).is_empty():
+		name = name.get_slice(":", 0)
+	var id: String = holder.get_scene_unique_id()
+	if not id.is_empty():
+		ids[id] = {name: true}
 	return ids
 
 
+## Adds what [param more] spares to [param into], both as [method reached] answers them; true for an
+## id spares the whole resource, as one a tool rebuilt.
+static func spare(into: Dictionary, more: Dictionary) -> void:
+	for id: Variant in more:
+		var held: Variant = into.get(id)
+		var given: Variant = more[id]
+		if held is bool or given is bool:
+			into[id] = true
+		elif held is Dictionary:
+			var names: Dictionary = held
+			var added: Dictionary = given
+			names.merge(added)
+		else:
+			into[id] = given
+
+
 ## Whether [param object] holds, at any depth, an embedded resource with a script that is not a tool.
 static func holds_scripted_embedded(object: Object, seen: Dictionary) -> bool:
 	for value: Variant in stored(object).values():
@@ -276,7 +295,7 @@ static func reads_the_same(was: Variant, now: Variant, default: Variant) -> bool
 			return false
 		else:
 			values.append(str_to_var(str(text)))
-	return GdhPropertyValues.same(values[0], values[1])
+	return GdhSame.same(values[0], values[1])
 
 
 static func _main_entries(text: String) -> Dictionary:
@@ -315,9 +334,9 @@ static func scripted_sections(text: String) -> Dictionary:
 
 ## Each property an embedded resource of [param after] sets differently from [param before], as
 ## [its id, name, whether before sets it, the text before gives it, the text after gives it or
-## null]. Only those with a script that
-## is not a tool are compared, since only a script runs differently here, and those in
-## [param reached_ids], which the tool changed, are left out.
+## null]. Only those with a script that is not a tool are compared, since only a script runs
+## differently here, and what [param reached_ids] says the tool wrote is left out, as
+## [method reached] answers it.
 static func embedded_changes(before: String, after: String, reached_ids: Dictionary) -> Array[Array]:
 	var changed: Array[Array] = []
 	if before.is_empty():
@@ -327,8 +346,10 @@ static func embedded_changes(before: String, after: String, reached_ids: Diction
 	for key: Variant in scripted_sections(before):
 		var section: String = str(key)
 		var id: String = section.trim_prefix("sub:")
-		if not section.begins_with("sub:") or reached_ids.has(id) or not new.has(section):
+		var spared: Variant = reached_ids.get(id, {})
+		if not section.begins_with("sub:") or spared is bool or not new.has(section):
 			continue
+		var written: Dictionary = spared
 		var was_section: Dictionary = old[section]
 		var now_section: Dictionary = new[section]
 		var was: Dictionary = entries_of(was_section)
@@ -337,7 +358,7 @@ static func embedded_changes(before: String, after: String, reached_ids: Diction
 		all.merge(now)
 		for entry: Variant in all:
 			var name: String = str(entry)
-			if was.get(name) != now.get(name):
+			if was.get(name) != now.get(name) and not written.has(name):
 				changed.append([id, name, was.has(name), str(was.get(name, "")), now.get(name)])
 	return changed
 

package/build/godot/addons/gdharness_editor/property_paths.gd

@@ -0,0 +1,225 @@
+@tool
+extends RefCounted
+
+## Where a property a tool writes lives: on the object given, on a resource built into it, or on an
+## element of one of its lists that the write has to make first.
+
+const GdhRead = preload("reading.gd")
+
+const HEADINGS: int = PROPERTY_USAGE_CATEGORY | PROPERTY_USAGE_GROUP | PROPERTY_USAGE_SUBGROUP
+
+
+## The entry [param target] declares for [param property], or {} when it declares none, headings
+## left out.
+static func declared_on(target: Object, property: String) -> Dictionary:
+	for declared: Dictionary in target.get_property_list():
+		if str(declared.get("name", "")) != property:
+			continue
+		if GdhRead.as_int(declared.get("usage", 0)) & HEADINGS:
+			continue
+		return declared
+	return {}
+
+
+## Where [param key] is written: as [holder, name, through], the object holding the property, its
+## name there, and the resources passed on the way. A key that is none of [param target]'s own may
+## start with the name of one holding a resource built into it, then a slash and a key of that
+## resource: "sources/0/0:0/0/probability" is the probability of tile 0:0 in the atlas source a
+## TileSet keeps as sources/0. A colon path cannot reach it, since the tile's own name holds colons.
+## A resource kept in a file of its own is not reached, nor, given the file [param home] that
+## [param target] is saved in, one built into another file, since writing it here would leave that
+## file as it was.
+static func holder_of(target: Object, key: String, home: String = "") -> Array:
+	var through: Array[Resource] = []
+	var holder: Object = target
+	var name: String = key
+	while declared_on(holder, name).is_empty():
+		var reached: Resource = null
+		var at: int = name.find("/")
+		while at > 0:
+			var held: Resource = built_in_at(holder, name.left(at), home)
+			if held != null:
+				reached = held
+				break
+			at = name.find("/", at + 1)
+		if reached == null:
+			break
+		through.append(reached)
+		holder = reached
+		name = name.substr(at + 1)
+	return [holder, name, through]
+
+
+## The resource [param target] holds under [param property] when it is built into a file, or null;
+## given [param home], only one built into that file or into none yet.
+static func built_in_at(target: Object, property: String, home: String = "") -> Resource:
+	var held: Resource = held_at(target, property)
+	if held == null or not held.is_built_in():
+		return null
+	var file: String = held.resource_path.get_slice("::", 0)
+	return held if home.is_empty() or file.is_empty() or file == home else null
+
+
+## The file [param target] is saved in: its scene's for a node, as the nodes of an instance are
+## saved in the scene holding it, and its own for a resource; "" when it has none yet.
+static func home_of(target: Object) -> String:
+	if target is Node:
+		var top: Node = target
+		while top.owner != null:
+			top = top.owner
+		return top.scene_file_path
+	if target is Resource:
+		var resource: Resource = target
+		return resource.resource_path.get_slice("::", 0)
+	return ""
+
+
+## The resource [param target] holds under [param property], built in or kept in a file, or null.
+static func held_at(target: Object, property: String) -> Resource:
+	if declared_on(target, property).is_empty():
+		return null
+	var held: Variant = target.get(property)
+	return held if held is Resource else null
+
+
+## Makes the element of a list [param name] names on [param target] when it is the next one, as the
+## inspector's Add Element does, and answers "" (also when [param name] is in no list), or why not,
+## [param called] being what [param target] is called. The engine lists an element's properties
+## only once the element exists, so a TileSet with no physics layer had no
+## physics_layer_0/collision_layer to write. A list the engine declares as an array grows through
+## the method named after its elements, add_physics_layer for physics_layer_, given the indices of
+## the lists around it; a list counted by a property, as a tile's polygons are by polygons_count,
+## grows by raising the count.
+static func grow(target: Object, name: String, called: String) -> String:
+	var steps: PackedStringArray = name.split("/")
+	for depth: int in steps.size() - 1:
+		var step: String = steps[depth]
+		var cut: int = step.rfind("_")
+		if cut < 1 or not step.substr(cut + 1).is_valid_int():
+			continue
+		var index: int = step.substr(cut + 1).to_int()
+		var above: String = "/".join(steps.slice(0, depth))
+		var under: String = above + "/" if not above.is_empty() else ""
+		var prefix: String = under + step.left(cut + 1)
+		var element: String = step.left(cut)
+		var counted: String = under + element + "s_count"
+		var count: int = -1
+		var adding: Callable
+		if not declared_on(target, counted).is_empty():
+			count = GdhRead.as_int(target.get(counted))
+			adding = func() -> void: target.set(counted, count + 1)
+		elif _listed_array(target, prefix):
+			count = _elements(target, prefix)
+			var method: String = "add_" + element
+			var outer: Array = []
+			for enclosing: String in steps.slice(0, depth):
+				var at: int = enclosing.rfind("_")
+				if at > 0 and enclosing.substr(at + 1).is_valid_int():
+					outer.append(enclosing.substr(at + 1).to_int())
+			if target.has_method(method):
+				adding = func() -> void: target.callv(method, outer)
+		if count < 0 or index < count:
+			continue
+		var held: String = (
+			"%s has %d %s%s"
+			% [
+				above if not above.is_empty() else called,
+				count,
+				element.replace("_", " "),
+				"" if count == 1 else "s"
+			]
+		)
+		if index > count:
+			return (
+				"%s, and a new one goes after the last, so %s%d cannot be written yet: write %s%d first."
+				% [held, prefix, index, prefix, count]
+			)
+		if not adding.is_valid():
+			return "%s, and nothing makes another, so %s cannot be written." % [held, name]
+		adding.call()
+		return ""
+	return ""
+
+
+## Whether [param target] declares a list whose elements' properties start with [param prefix],
+## as TileSet declares physics_layers for physics_layer_0/collision_layer.
+static func _listed_array(target: Object, prefix: String) -> bool:
+	for declared: Dictionary in target.get_property_list():
+		var usage: int = GdhRead.as_int(declared.get("usage", 0))
+		if usage & PROPERTY_USAGE_ARRAY and str(declared.get("class_name", "")) == prefix:
+			return true
+	return false
+
+
+## How many elements of the list whose properties start with [param prefix] [param target] holds.
+static func _elements(target: Object, prefix: String) -> int:
+	var count: int = 0
+	for declared: Dictionary in target.get_property_list():
+		var name: String = str(declared.get("name", ""))
+		if not name.begins_with(prefix):
+			continue
+		var index: String = name.substr(prefix.length()).get_slice("/", 0)
+		if index.is_valid_int():
+			count = maxi(count, index.to_int() + 1)
+	return count
+
+
+## What [param target] is called in a refusal: the class_name its script declares, or else its
+## engine class. A resource made as a project class is a Resource to the engine, and "Resource.kind"
+## named a property no Resource has.
+static func class_called(target: Object) -> String:
+	var attached: Variant = target.get_script()
+	if attached is Script:
+		var script: Script = attached
+		if not str(script.get_global_name()).is_empty():
+			return str(script.get_global_name())
+	return target.get_class()
+
+
+## The refusal for [param name], which [param target] does not declare, when it runs through a
+## resource saved in a file other than [param home], the one [param target] is saved in; or "". The
+## write belongs in that file, since this one would be saved and that one left as it was: through a
+## TileMapLayer's tile_set kept in a file of its own, or through the mesh of an instance's editable
+## child, which is built into the scene the instance comes from.
+static func held_elsewhere(target: Object, name: String, home: String) -> String:
+	var at: int = name.find("/")
+	while at > 0:
+		var head: String = name.left(at)
+		var rest: String = name.substr(at + 1)
+		var held: Resource = held_at(target, head)
+		var file: String = "" if held == null else held.resource_path.get_slice("::", 0)
+		if held != null and not held.is_built_in():
+			return (
+				"%s.%s is %s, a file of its own, so %s is written there, with resource_edit modify on %s."
+				% [class_called(target), head, file, rest, file]
+			)
+		if held != null and not file.is_empty() and not home.is_empty() and file != home:
+			return _built_in_elsewhere(target, head, rest, held, file)
+		at = name.find("/", at + 1)
+	return ""
+
+
+## The refusal for writing [param rest] into [param held], which [param target] holds under
+## [param head] and which is built into [param file], the scene an instance in this one comes from.
+static func _built_in_elsewhere(
+	target: Object, head: String, rest: String, held: Resource, file: String
+) -> String:
+	var node: String = ""
+	if target is Node:
+		var placed: Node = target
+		var from: Node = placed
+		while from != null and from.scene_file_path != file:
+			from = from.owner
+		if from != null:
+			node = " on %s" % from.get_path_to(placed)
+	var text: String = (
+		(
+			"%s.%s is built into %s, so %s is written there, with scene_node set%s in %s, which changes "
+			+ "it wherever that scene is used. To change it here alone, give %s a %s of its own: a "
+			+ 'value with "_type" set to its class and its properties beside it.'
+		)
+		% [class_called(target), head, file, rest, node, file, head, held.get_class()]
+	)
+	if target is GeometryInstance3D and (held is Material or rest.contains("material")):
+		text += " A material for this instance alone goes in material_override."
+	return text

package/build/godot/addons/gdharness_editor/property_paths.gd.uid

@@ -0,0 +1 @@
+uid://mi7vnabydtlw