gdharness 1.3.3 → 1.3.5

package/build/godot/addons/gdharness_editor/tools/signal_tools.gd

@@ -0,0 +1,363 @@
+@tool
+extends Node
+
+## Signal connections in a scene file, made, removed and listed on a copy of the file as the other
+## scene tools edit one.
+
+const GdhRead = preload("../reading.gd")
+const GdhSceneFile = preload("../scene_file.gd")
+
+## What every emission meets when a connection cannot call its method.
+const FAILS: String = ", so every emission fails to call it."
+
+
+func connect_signal(args: Dictionary) -> Dictionary:
+	var project_path: String = str(args.get("projectPath", ""))
+	var scene_path: String = GdhSceneFile.res_path(project_path, str(args.get("scenePath", "")))
+	var source_node_path: String = str(args.get("sourceNodePath", ""))
+	var signal_name: String = str(args.get("signalName", ""))
+	var target_node_path: String = str(args.get("targetNodePath", ""))
+	var method_name: String = str(args.get("methodName", ""))
+	# A connection without CONNECT_PERSIST is a runtime one, and PackedScene.pack drops those on
+	# the way out: without this the scene saves unchanged and this answers success over nothing.
+	var flags: int = GdhRead.as_int(args.get("flags", 0)) | Object.CONNECT_PERSIST
+
+	if (
+		source_node_path.is_empty()
+		or signal_name.is_empty()
+		or target_node_path.is_empty()
+		or method_name.is_empty()
+	):
+		return {"ok": false, "error": "Missing required signal connection arguments"}
+
+	var scene: GdhSceneFile = GdhSceneFile.new()
+	var refused: Dictionary = scene.open(scene_path, true)
+	if not refused.is_empty():
+		return refused
+
+	var ends: Array = _connection_ends(scene, source_node_path, signal_name, target_node_path)
+	if ends[0] == null:
+		return scene.refuse(str(ends[1]))
+	var source: Node = ends[0]
+	var target: Node = ends[1]
+
+	# Reconnected rather than left alone when the flags differ, so the connection saved is the one
+	# asked for. Left alone, the answer gave the flags asked for and the file kept the old ones.
+	var callable: Callable = Callable(target, method_name)
+	var method_found: bool = target.has_method(method_name)
+	var misfit: String = _misfit(source, signal_name, callable, flags)
+	var flags_before: int = -1
+	for connection: Dictionary in source.get_signal_connection_list(signal_name):
+		if connection.get("callable") == callable:
+			flags_before = GdhRead.as_int(connection.get("flags", 0))
+	if source.is_connected(signal_name, callable):
+		source.disconnect(signal_name, callable)
+	var connect_result: Error = source.connect(signal_name, callable, flags)
+	if connect_result != OK:
+		return scene.refuse("Failed to connect signal: " + error_string(connect_result))
+
+	var from: String = scene.path_of(source)
+	var to: String = scene.path_of(target)
+	var saved_flags: Array = [-1]
+	var written: Dictionary = scene.write(
+		func(saved: Node) -> String:
+			saved_flags[0] = _connection_flags(saved, from, signal_name, to, method_name)
+			if saved_flags[0] < 0:
+				return "the connection would not be in the scene when it loads."
+			return ""
+	)
+	if not written.is_empty():
+		return written
+
+	var answer: Dictionary = {
+		"ok": true,
+		"sourceNodePath": from,
+		"signalName": signal_name,
+		"targetNodePath": to,
+		"methodName": method_name,
+		"flags": saved_flags[0],
+		"flagNames": GdhSceneFile.flag_names(GdhRead.as_int(saved_flags[0])),
+		# Connected either way, as the editor's own dialog allows, since the method may be written
+		# next; a caller told nothing learnt of a misspelt one only when the signal fired.
+		"methodFound": method_found
+	}
+	# Written all the same, for the reason a missing method is: the method may be changed next.
+	if method_found:
+		answer["argumentsFit"] = misfit.is_empty()
+	if not misfit.is_empty():
+		answer["misfit"] = misfit
+	# A second connect of the same pair read exactly like the first, so a caller could not tell a
+	# connection made from one that was already there, and a list showing one where two were made
+	# looked like a lost write.
+	if flags_before >= 0:
+		answer["alreadyConnected"] = true
+		if flags_before != GdhRead.as_int(saved_flags[0]):
+			answer["flagsBefore"] = GdhSceneFile.flag_names(flags_before)
+	return answer
+
+
+## The two ends of a connection in [param scene], as [source, target], or [null, why not].
+func _connection_ends(
+	scene: GdhSceneFile, source_node_path: String, signal_name: String, target_node_path: String
+) -> Array:
+	var source: Node = GdhSceneFile.node_at(scene.root, source_node_path)
+	var target: Node = GdhSceneFile.node_at(scene.root, target_node_path)
+	if not source:
+		return [null, scene.not_found("Source node not found: " + source_node_path, source_node_path)]
+	if not target:
+		return [null, scene.not_found("Target node not found: " + target_node_path, target_node_path)]
+	# pack drops a connection with either end inside an instanced scene, and the answer said it was
+	# made or removed.
+	for end: Node in [source, target]:
+		var foreign: String = scene.foreign(end)
+		if not foreign.is_empty():
+			return [null, foreign]
+	if not source.has_signal(signal_name):
+		var said: String = "%s has no signal %s" % [source_node_path, signal_name]
+		var offered: String = GdhRead.offered(said, signal_name, GdhRead.signals_of(source))
+		return [null, GdhSceneFile.missing_on(source, offered)]
+	return [source, target]
+
+
+## The flags of the persistent connection from [param from]'s [param signal_name] to
+## [param method] on [param to] in the tree under [param root], or -1 when there is none.
+func _connection_flags(root: Node, from: String, signal_name: String, to: String, method: String) -> int:
+	var source: Node = root.get_node_or_null(from)
+	var target: Node = root.get_node_or_null(to)
+	if source == null or target == null or not source.has_signal(signal_name):
+		return -1
+	for conn: Dictionary in source.get_signal_connection_list(signal_name):
+		var flags: int = GdhRead.as_int(conn.get("flags", 0))
+		var callable: Callable = conn.get("callable", Callable())
+		if (
+			flags & Object.CONNECT_PERSIST
+			and callable.get_object() == target
+			and str(callable.get_method()) == method
+		):
+			return flags
+	return -1
+
+
+## Why what [param signal_name] of [param source] passes cannot reach [param callable], or "" when it
+## can or the method is not there to judge. Only what fails on every emission is named: too few or
+## too many arguments, an object passed where the method takes a value or the reverse, and an engine
+## class unrelated to the one the method takes. Anything that may convert or narrow when it runs is
+## left alone, since a warning about a connection that works is one nobody can act on.
+static func _misfit(source: Node, signal_name: String, callable: Callable, flags: int) -> String:
+	var target: Object = callable.get_object()
+	var method: String = str(callable.get_method())
+	var taken: Dictionary = {}
+	for info: Dictionary in target.get_method_list() if target != null else []:
+		if str(info.get("name", "")) == method:
+			taken = info
+			break
+	if taken.is_empty() or GdhRead.as_int(taken.get("flags", 0)) & METHOD_FLAG_VARARG:
+		return ""
+	var passed: Array[Dictionary] = []
+	for info: Dictionary in source.get_signal_list():
+		if str(info.get("name", "")) == signal_name:
+			for argument: Dictionary in info.get("args", []):
+				passed.append(argument)
+			break
+	if flags & Object.CONNECT_APPEND_SOURCE_OBJECT:
+		passed.append({"name": "source", "type": TYPE_OBJECT, "class_name": source.get_class()})
+	passed = passed.slice(0, maxi(passed.size() - callable.get_unbound_arguments_count(), 0))
+	for bound: Variant in callable.get_bound_arguments():
+		var bound_class: String = ""
+		if bound is Object:
+			var object: Object = bound
+			bound_class = object.get_class()
+		passed.append({"name": "bound", "type": typeof(bound), "class_name": bound_class})
+
+	var parameters: Array = taken.get("args", [])
+	var defaults: Array = taken.get("default_args", [])
+	var needed: int = parameters.size() - defaults.size()
+	if passed.size() < needed:
+		return "%s passes %s, and %s needs %d%s" % [signal_name, _count(passed.size()), method, needed, FAILS]
+	if passed.size() > parameters.size():
+		var most: String = "none" if parameters.is_empty() else "at most %d" % parameters.size()
+		return "%s passes %s, and %s takes %s%s" % [signal_name, _count(passed.size()), method, most, FAILS]
+	for at: int in passed.size():
+		var given: Dictionary = passed[at]
+		var parameter: Dictionary = parameters[at]
+		if not _unrelated(given, parameter):
+			continue
+		return (
+			"%s passes argument %d as %s, and %s takes it as %s: %s%s"
+			% [
+				signal_name,
+				at + 1,
+				_type_named(given),
+				method,
+				str(parameter.get("name", "")),
+				_type_named(parameter),
+				FAILS
+			]
+		)
+	return ""
+
+
+## Whether a value declared as [param given] can never be passed as [param parameter].
+static func _unrelated(given: Dictionary, parameter: Dictionary) -> bool:
+	var given_type: int = GdhRead.as_int(given.get("type", TYPE_NIL))
+	var taken_type: int = GdhRead.as_int(parameter.get("type", TYPE_NIL))
+	if given_type == TYPE_NIL or taken_type == TYPE_NIL:
+		return false
+	if (given_type == TYPE_OBJECT) != (taken_type == TYPE_OBJECT):
+		return true
+	if given_type != TYPE_OBJECT:
+		return false
+	var given_class: String = str(given.get("class_name", ""))
+	var taken_class: String = str(parameter.get("class_name", ""))
+	# A class a script declares is not in ClassDB, and an engine class can still hold an instance of
+	# one, so only two engine classes are judged.
+	if not ClassDB.class_exists(given_class) or not ClassDB.class_exists(taken_class):
+		return false
+	return (
+		not ClassDB.is_parent_class(given_class, taken_class)
+		and not ClassDB.is_parent_class(taken_class, given_class)
+	)
+
+
+static func _type_named(declared: Dictionary) -> String:
+	var type: int = GdhRead.as_int(declared.get("type", TYPE_NIL))
+	var named: String = str(declared.get("class_name", ""))
+	if type == TYPE_OBJECT and not named.is_empty():
+		return named
+	return type_string(type)
+
+
+static func _count(arguments: int) -> String:
+	if arguments == 0:
+		return "no arguments"
+	return "1 argument" if arguments == 1 else "%d arguments" % arguments
+
+
+func disconnect_signal(args: Dictionary) -> Dictionary:
+	var project_path: String = str(args.get("projectPath", ""))
+	var scene_path: String = GdhSceneFile.res_path(project_path, str(args.get("scenePath", "")))
+	var source_node_path: String = str(args.get("sourceNodePath", ""))
+	var signal_name: String = str(args.get("signalName", ""))
+	var target_node_path: String = str(args.get("targetNodePath", ""))
+	var method_name: String = str(args.get("methodName", ""))
+
+	if (
+		source_node_path.is_empty()
+		or signal_name.is_empty()
+		or target_node_path.is_empty()
+		or method_name.is_empty()
+	):
+		return {"ok": false, "error": "Missing required signal disconnection arguments"}
+
+	var scene: GdhSceneFile = GdhSceneFile.new()
+	var refused: Dictionary = scene.open(scene_path, true)
+	if not refused.is_empty():
+		return refused
+
+	var ends: Array = _connection_ends(scene, source_node_path, signal_name, target_node_path)
+	if ends[0] == null:
+		return scene.refuse(str(ends[1]))
+	var source: Node = ends[0]
+	var target: Node = ends[1]
+
+	var from: String = scene.path_of(source)
+	var to: String = scene.path_of(target)
+	# A connection that was never there saved the scene unchanged and answered as removed, so a
+	# typo in either name read as success.
+	if _connection_flags(scene.root, from, signal_name, to, method_name) < 0:
+		return scene.refuse(
+			"%s has no connection from %s.%s to %s.%s." % [scene_path, from, signal_name, to, method_name]
+		)
+	source.disconnect(signal_name, Callable(target, method_name))
+
+	var written: Dictionary = scene.write(
+		func(saved: Node) -> String:
+			if _connection_flags(saved, from, signal_name, to, method_name) >= 0:
+				return "the connection would still be in the scene when it loads."
+			return ""
+	)
+	if not written.is_empty():
+		return written
+
+	return {
+		"ok": true,
+		"removed": true,
+		"sourceNodePath": from,
+		"signalName": signal_name,
+		"targetNodePath": to,
+		"methodName": method_name
+	}
+
+
+func list_connections(args: Dictionary) -> Dictionary:
+	var project_path: String = str(args.get("projectPath", ""))
+	var scene_path: String = GdhSceneFile.res_path(project_path, str(args.get("scenePath", "")))
+	var filter_path: String = str(args.get("nodePath", ""))
+
+	var scene: GdhSceneFile = GdhSceneFile.new()
+	var refused: Dictionary = scene.open(scene_path, false)
+	if not refused.is_empty():
+		return refused
+
+	var root: Node = scene.root
+	var filtered: Node = null
+	if not filter_path.is_empty():
+		filtered = GdhSceneFile.node_at(root, filter_path)
+		if filtered == null:
+			return scene.refuse(scene.not_found("Node not found: " + filter_path, filter_path))
+	var nodes: Array = []
+	_collect_nodes_recursive(root, ".", nodes)
+
+	# Only persistent connections, which are the ones a scene file holds: a Container connects
+	# signals of each child to itself as the child is added, and those were answered as if the file
+	# held them. Matched on either end, since the filter is for connections involving the node.
+	var connections: Array = []
+	for entry: Dictionary in nodes:
+		var path: String = str(entry["path"])
+		var node: Node = entry["node"]
+		for signal_info: Dictionary in node.get_signal_list():
+			var signal_name: String = str(signal_info.get("name", ""))
+			if signal_name.is_empty():
+				continue
+			for conn: Dictionary in node.get_signal_connection_list(signal_name):
+				var flags: int = GdhRead.as_int(conn.get("flags", 0))
+				if not flags & Object.CONNECT_PERSIST:
+					continue
+				var callable: Callable = conn.get("callable", Callable())
+				var target_obj: Object = callable.get_object()
+				if filtered != null and node != filtered and target_obj != filtered:
+					continue
+				var target_path: String = ""
+				var editable: bool = scene.foreign(node).is_empty()
+				if target_obj is Node:
+					target_path = str(root.get_path_to(target_obj as Node))
+					editable = editable and scene.foreign(target_obj as Node).is_empty()
+				var listed: Dictionary = {
+					"sourceNodePath": path,
+					"signalName": signal_name,
+					"targetNodePath": target_path,
+					"methodName": str(callable.get_method()),
+					"flags": flags,
+					"flagNames": GdhSceneFile.flag_names(flags),
+					# False for a connection an instanced scene makes inside itself, which only that
+					# scene can change.
+					"editable": editable,
+					"methodFound": target_obj != null and target_obj.has_method(callable.get_method()),
+				}
+				var misfit: String = _misfit(node, signal_name, callable, flags)
+				if not misfit.is_empty():
+					listed["misfit"] = misfit
+				connections.append(listed)
+
+	scene.close()
+	var answer: Dictionary = {"ok": true, "connections": connections}
+	if Engine.is_editor_hint():
+		answer["unsavedInEditor"] = GdhSceneFile.unsaved(scene_path)
+	return answer
+
+
+func _collect_nodes_recursive(node: Node, path: String, out_nodes: Array) -> void:
+	out_nodes.append({"path": path, "node": node})
+	for child: Node in node.get_children():
+		var child_path: String = str(child.name) if path == "." else path + "/" + str(child.name)
+		_collect_nodes_recursive(child, child_path, out_nodes)

package/build/godot/addons/gdharness_editor/tools/signal_tools.gd.uid

@@ -0,0 +1 @@
+uid://8ktrjlekhgex

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

@@ -0,0 +1,293 @@
+@tool
+extends RefCounted
+
+## What a property declares beyond its type: the values of its enum and the range it is exported
+## with, for taking a value by name and for saying when a value written lies outside them.
+
+const GdhRead = preload("reading.gd")
+
+
+## The values an enum hint names, by name, from its hint string: "SWORD:0,SHIELD:1" as a script
+## declares one, or "Add,Subtract" as an engine property does, each name then taking the number
+## after the one before it.
+static func enum_values(hint_string: String) -> Dictionary:
+	var values: Dictionary = {}
+	var next: int = 0
+	for entry: String in hint_string.split(",", false):
+		var name: String = entry.get_slice(":", 0).strip_edges()
+		var number: String = entry.get_slice(":", 1).strip_edges() if ":" in entry else ""
+		var value: int = number.to_int() if number.is_valid_int() else next
+		values[name] = value
+		next = value + 1
+	return values
+
+
+## The values of the enum [param declared] declares, by name, spelt as the script of [param target]
+## spells them when it declares that enum. The engine's hint capitalises each name, "SWORD" as
+## "Sword", and a refusal listing those named values the script never spells.
+static func enum_of(target: Object, declared: Dictionary) -> Dictionary:
+	var hinted: Dictionary = enum_values(str(declared.get("hint_string", "")))
+	var attached: Variant = target.get_script()
+	if not attached is Script:
+		return hinted
+	var script: Script = attached
+	for constant: Variant in script.get_script_constant_map().values():
+		if not constant is Dictionary:
+			continue
+		var values: Dictionary = constant
+		if values.size() != hinted.size():
+			continue
+		var spelt: Dictionary = {}
+		for name: Variant in values:
+			if hinted.get(str(name).capitalize()) == values[name]:
+				spelt[str(name)] = values[name]
+		if spelt.size() == hinted.size():
+			return spelt
+	return hinted
+
+
+## The number [param word] names among [param choices], matched as written and then ignoring case,
+## or null when it names none.
+static func enum_named(choices: Dictionary, word: String) -> Variant:
+	var wanted: String = word.strip_edges()
+	if choices.has(wanted):
+		return choices[wanted]
+	for name: String in choices:
+		if name.to_lower() == wanted.to_lower():
+			return choices[name]
+	return null
+
+
+## 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
+
+
+## [param word] as the number of the value the enum property [param declared] of [param target]
+## names by it, as [true, number], or [false, why] naming the values, with [param holder] naming the
+## target in the refusal. [false, ""] for a word that is a number, which converts as one.
+##
+## An enum is written by the name of a value as well as its number, since the name is what the script
+## and the inspector show and the number is only where the value happens to sit. Tried as the script
+## spells it, then as the hint does, then as the engine's constant.
+static func enum_by_name(target: Object, declared: Dictionary, word: String, holder: String) -> Array:
+	var property: String = str(declared.get("name", ""))
+	var choices: Dictionary = enum_of(target, declared)
+	var chosen: Variant = enum_named(choices, word)
+	if chosen == null:
+		chosen = enum_named(enum_values(str(declared.get("hint_string", ""))), word)
+	var constants: Dictionary = {}
+	if chosen == null:
+		constants = engine_constants(target, property)
+		chosen = enum_named(constants, word)
+	if chosen != null:
+		return [true, chosen]
+	if word.strip_edges().is_valid_int():
+		return [false, ""]
+	return [false, enum_refusal(holder, property, word, choices, constants)]
+
+
+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 %s"
+		% [holder, property, word, _listed(choices), ways]
+	)
+	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)]
+
+
+## Why [param value], shown as [param shown], lies outside what [param declared] allows, an export
+## range or an enum's values, or "" when it does not. A range marked or_greater or or_less is open
+## on that side.
+static func outside(target: Object, declared: Dictionary, value: Variant, shown: String) -> String:
+	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)
+	if hint == PROPERTY_HINT_ENUM and typeof(value) == TYPE_INT:
+		var choices: Dictionary = enum_of(target, declared)
+		if choices.is_empty() or choices.values().has(value):
+			return ""
+		return "%d is none of the values %s declares: %s." % [value, property, _listed(choices)]
+	if hint != PROPERTY_HINT_RANGE:
+		return ""
+	var parts: PackedStringArray = []
+	for part: String in hint_string.split(","):
+		var _added: bool = parts.append(part.strip_edges())
+	if parts.size() < 2 or not parts[0].is_valid_float() or not parts[1].is_valid_float():
+		return ""
+	var low: float = parts[0].to_float()
+	var high: float = parts[1].to_float()
+	if (number <= high or parts.has("or_greater")) and (number >= low or parts.has("or_less")):
+		return ""
+	return (
+		(
+			"%s is outside the range %s declares, %s to %s, which the inspector holds it to; the "
+			+ "engine stores it as given."
+		)
+		% [shown, property, _bound(low), _bound(high)]
+	)
+
+
+static func _listed(choices: Dictionary) -> String:
+	var listed: PackedStringArray = []
+	for name: String in choices:
+		var _added: bool = listed.append("%s (%d)" % [name, choices[name]])
+	return ", ".join(listed)
+
+
+## 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_runtime/declared_values.gd.uid

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

package/build/godot/addons/gdharness_runtime/reading.gd

@@ -189,6 +189,21 @@ static func offered(said: String, word: String, names: Array) -> String:
 	return "%s; the nearest it has %s %s" % [said, "is" if close.size() == 1 else "are", ", ".join(close)]
 
 
+## [param said], the refusal for [param property], which [param target] does not declare, with the
+## names it declares nearest it when any are, as a misspelt one is usually one of them. Unlike
+## [method offered], nothing is listed when none is near, since an object declares a hundred.
+static func near_property(said: String, target: Object, property: String) -> String:
+	var headings: int = PROPERTY_USAGE_CATEGORY | PROPERTY_USAGE_GROUP | PROPERTY_USAGE_SUBGROUP
+	var names: Array[String] = []
+	for declared: Dictionary in target.get_property_list():
+		if not as_int(declared.get("usage", 0)) & headings:
+			names.append(str(declared.get("name", "")))
+	var close: PackedStringArray = nearest(property, PackedStringArray(names))
+	if close.is_empty():
+		return said
+	return "%s; the nearest it has %s %s" % [said, "is" if close.size() == 1 else "are", ", ".join(close)]
+
+
 ## The signals [param object] has that a caller can connect, its own class's first: the engine
 ## lists them from Object down, which puts a Button's pressed after thirty a Control has, and names
 ## starting with an underscore are the engine's own.