gdharness 1.3.34 → 1.3.36

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

@@ -131,6 +131,22 @@ static func _summary(anim: Animation) -> Dictionary:
 	}
 
 
+## [param seconds], a key's time, as the shortest decimal holding the same 32-bit float. A scene keeps
+## key times as 32-bit floats, so a key put at 0.7 read back as 0.699999988079071.
+static func key_time(seconds: float) -> float:
+	var held: float = PackedFloat32Array([seconds])[0]
+	for places: int in range(0, 10):
+		var shorter: float = String.num(held, places).to_float()
+		if PackedFloat32Array([shorter])[0] == held:
+			return shorter
+	return held
+
+
+## Whether two times are one key's: the same 32-bit float, as a scene stores them.
+static func same_time(first: float, second: float) -> bool:
+	return PackedFloat32Array([first])[0] == PackedFloat32Array([second])[0]
+
+
 static func _track(anim: Animation, track: int, values: GdhSerialisation) -> Dictionary:
 	var kind: int = anim.track_get_type(track)
 	var path: NodePath = anim.track_get_path(track)
@@ -143,7 +159,7 @@ static func _track(anim: Animation, track: int, values: GdhSerialisation) -> Dic
 	var keyframes: Array[Dictionary] = []
 	var methods: Dictionary = {}
 	for key: int in anim.track_get_key_count(track):
-		var keyframe: Dictionary = {"time": anim.track_get_key_time(track, key)}
+		var keyframe: Dictionary = {"time": key_time(anim.track_get_key_time(track, key))}
 		if kind == Animation.TYPE_METHOD:
 			var method: String = str(anim.method_track_get_name(track, key))
 			methods[method] = true

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

@@ -215,7 +215,8 @@ static func offered(said: String, word: String, names: Array) -> String:
 ## [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, or else the
 ## variables its script declares. The engine's own are not listed when none is near, since an object
-## has a hundred, while a script's are the few a caller most likely meant.
+## has a hundred, while a script's are the few a caller most likely meant; an object with no script
+## is told where they are listed instead, since the refusal alone left nothing to try.
 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] = []
@@ -233,8 +234,15 @@ static func near_property(said: String, target: Object, property: String) -> Str
 	var close: PackedStringArray = nearest(property, PackedStringArray(names))
 	if not close.is_empty():
 		return "%s; the nearest it has %s %s" % [said, "is" if close.size() == 1 else "are", ", ".join(close)]
-	if scripted.is_empty():
+	# With a script that declares nothing readable, as one that does not compile, the name is likelier
+	# the script's than the class's, so the class's list would point the wrong way.
+	if scripted.is_empty() and target.get_script() != null:
 		return said
+	if scripted.is_empty():
+		return (
+			"%s; editor_classes info with className %s and includeInherited true lists the ones it has"
+			% [said, target.get_class()]
+		)
 	scripted.sort()
 	return "%s; its script declares %s" % [said, ", ".join(PackedStringArray(scripted))]
 

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

@@ -630,11 +630,12 @@ func write(check: Callable = Callable()) -> Dictionary:
 	}
 
 
-## Each property [param state] stores differently from the file, on a node the file held and the call
-## did not ask to change, as {node, property, was, saved}: was left out where the file did not set it,
-## saved where the write does not. The engine writes a node as it holds it once the file has loaded,
-## and one property can set others as it loads, as anchors_preset gives a centred Control both grow
-## directions, so a file not written by the editor gains lines on nodes nobody named.
+## Each property [param state] stores differently from the file, on a node the file held, that the
+## call neither asked for nor changed, as {node, property, was, saved}: was left out where the file did
+## not set it, saved where the write does not. The engine writes a node as it holds it once the file
+## has loaded, and one property can set others as it loads, as anchors_preset gives a centred Control
+## both grow directions, so a file not written by the editor gains lines on any node, the one a set
+## names among them. What the call's own change moved on that node is its answer's alsoChanged.
 func _also_saved(state: SceneState) -> Array[Dictionary]:
 	var noted: Array[Dictionary] = []
 	var values: GdhSerialisation = GdhSerialisation.new()
@@ -643,14 +644,19 @@ func _also_saved(state: SceneState) -> Array[Dictionary]:
 		if node == null:
 			continue
 		var id: int = node.get_instance_id()
-		if _asked.has(id) or not _filed.has(id):
+		if not _filed.has(id):
 			continue
+		# What the call set on it, and what the engine moved as it did, which the answer gives as
+		# alsoChanged.
+		var on: Dictionary = _asked.get(id, {})
 		var filed: Dictionary = _filed[id]
 		var stored: Dictionary = _stored_at(state, index)
 		var names: Dictionary = filed.duplicate()
 		names.merge(stored)
 		for key: Variant in names:
 			var name: String = str(key)
+			if on.has(name):
+				continue
 			var held: bool = filed.has(name)
 			if held == stored.has(name) and (not held or GdhSame.same(stored[name], filed[name])):
 				continue

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

@@ -306,6 +306,10 @@ func remove_animation_track(args: Dictionary) -> Dictionary:
 	var property: String = str(track.get("property", ""))
 	var shape: Array = [track_type, node_path, property]
 	var method: String = str(track.get("method", "")) if track_type == "method" else ""
+	var read_times: Variant = _times_of(args.get("times"))
+	if read_times is String:
+		return {"ok": false, "error": read_times}
+	var times: Array = read_times
 
 	var found: Array = _animation_at(scene_path, player_node_path, animation_name)
 	if found[1] == null:
@@ -345,6 +349,12 @@ func remove_animation_track(args: Dictionary) -> Dictionary:
 				% [animation_name, node_path, method, ", ".join(_methods_called(anim, matching))]
 			)
 		)
+	if not times.is_empty():
+		var timed: Array = _keys_at(anim, calling, times)
+		if timed[1] != "":
+			var on: String = node_path if property.is_empty() else "%s:%s" % [node_path, property]
+			return scene.refuse("%s's %s track on %s %s" % [animation_name, track_type, on, timed[1]])
+		calling = timed[0]
 	var keys: int = 0
 	var tracks_removed: int = 0
 	calling.reverse()
@@ -404,6 +414,53 @@ static func _keys_calling(anim: Animation, matching: Array[int], method: String)
 	return calling
 
 
+## The key times [param given] names, as floats, empty when it is null, or the String refusing it.
+static func _times_of(given: Variant) -> Variant:
+	var times: Array = []
+	if given == null:
+		return times
+	if not given is Array:
+		return "times is a list of the key times to remove, in seconds"
+	var listed: Array = given
+	if listed.is_empty():
+		return "times is a list of the key times to remove, in seconds"
+	for time: Variant in listed:
+		if not (time is float or time is int):
+			return "times holds %s, which is not a number of seconds" % str(time)
+		times.append(GdhRead.as_float(time))
+	return times
+
+
+## Of the keys [param calling] names, as [method _keys_calling] answers them, the ones at
+## [param times], as [[[track, key]...], ""], or with the second the words refusing a time none is at.
+## Removing a key took removing its whole track, so moving one key in time rewrote every other.
+static func _keys_at(anim: Animation, calling: Array, times: Array) -> Array:
+	var at: Array = []
+	var held: PackedStringArray = []
+	var missed: Array = times.duplicate()
+	for pair: Array in calling:
+		var index: int = pair[0]
+		for key: int in anim.track_get_key_count(index):
+			if pair[1] >= 0 and key != pair[1]:
+				continue
+			var time: float = anim.track_get_key_time(index, key)
+			var _listed: bool = held.append(str(GdhAnimationReads.key_time(time)))
+			for given: float in times:
+				if GdhAnimationReads.same_time(time, given):
+					at.append([index, key])
+					missed.erase(given)
+					break
+	if missed.is_empty():
+		return [at, ""]
+	var named: PackedStringArray = []
+	for given: float in missed:
+		var _named: bool = named.append(str(given))
+	return [
+		at,
+		"has no key at %s s; its keys are at %s s. Nothing was removed." % [", ".join(named), ", ".join(held)]
+	]
+
+
 ## The methods the keys of the tracks [param matching] call, each once.
 static func _methods_called(anim: Animation, matching: Array[int]) -> PackedStringArray:
 	var called: PackedStringArray = []

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

@@ -168,8 +168,20 @@ func scan_status(_args: Dictionary) -> Dictionary:
 	if not _editor_plugin:
 		return {"ok": false, "error": "Editor plugin unavailable"}
 	var filesystem: EditorFileSystem = EditorInterface.get_resource_filesystem()
+	# The scenes open in tabs, the one shown and the ones holding unsaved edits: a scene edit on disk
+	# meets what the editor holds of it, and nothing said which scenes those were. A tab of a scene
+	# never saved has no path, and a new project's editor opens with an empty one, so it is left out
+	# of the open; one with edits is kept among the unsaved, as the edits a close would lose.
+	var shown: Node = EditorInterface.get_edited_scene_root()
+	var open: Array[String] = []
+	open.assign(Array(EditorInterface.get_open_scenes()).filter(_has_path))
+	var unsaved: Array[String] = []
+	unsaved.assign(EditorInterface.get_unsaved_scenes())
 	return {
 		"ok": true,
+		"openScenes": open,
+		"editedScene": "" if shown == null else shown.scene_file_path,
+		"unsavedScenes": unsaved,
 		"scanning": filesystem.is_scanning(),
 		"importing": filesystem.is_importing(),
 		"pending": GdhSceneFile.scan_due,
@@ -179,6 +191,10 @@ func scan_status(_args: Dictionary) -> Dictionary:
 	}
 
 
+func _has_path(path: String) -> bool:
+	return path != ""
+
+
 ## Reimport the files named under `paths`, whatever their state, the way the editor's Reimport
 ## button does, and report whether the reimport was started.
 ##

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

@@ -24,8 +24,26 @@ static func bake(scene: GdhSceneFile, region: Node) -> Dictionary:
 	var at: String = scene.path_of(region)
 	var flat: bool = region is NavigationRegion2D
 	if not flat and not region is NavigationRegion3D:
-		return scene.refuse(
-			"%s is a %s, not a NavigationRegion2D or a NavigationRegion3D." % [at, region.get_class()]
+		var regions: PackedStringArray = []
+		for node: Node in _all_under(scene.root):
+			if node is NavigationRegion2D or node is NavigationRegion3D:
+				var _named: bool = regions.append(scene.path_of(node))
+		return (
+			scene
+			. refuse(
+				(
+					"%s is a %s, not a NavigationRegion2D or a NavigationRegion3D; %s."
+					% [
+						at,
+						region.get_class(),
+						(
+							"the scene has none, and scene_node add puts one in"
+							if regions.is_empty()
+							else "the scene's are at %s" % ", ".join(regions)
+						),
+					]
+				)
+			)
 		)
 	var property: String = "navigation_polygon" if flat else "navigation_mesh"
 	var held: Resource = region.get(property)
@@ -64,6 +82,8 @@ static func bake(scene: GdhSceneFile, region: Node) -> Dictionary:
 		)
 	if polygons == 0:
 		answer["note"] = _why_empty(held, flat, parsed)
+	elif flat and not parsed:
+		answer["note"] = _nothing_read(scene, held)
 	if not flat and not Engine.is_editor_hint() and _reads_meshes(region, held):
 		answer["meshesNote"] = (
 			"The engine's warning that it had to parse RenderingServer meshes at runtime is about a "
@@ -97,7 +117,7 @@ static func bake(scene: GdhSceneFile, region: Node) -> Dictionary:
 
 
 ## Reads the source geometry for [param held] off a copy of the region at [param at] and bakes it
-## into [param held], answering whether the copy gave any geometry.
+## into [param held], answering whether the copy gave any geometry: in 2D, any obstacle.
 static func _parse_and_bake(scene: GdhSceneFile, at: String, held: Resource, flat: bool) -> bool:
 	var copy: Node = scene.root.duplicate(Node.DUPLICATE_GROUPS)
 	var reading: Resource = held.duplicate()
@@ -116,7 +136,12 @@ static func _parse_and_bake(scene: GdhSceneFile, at: String, held: Resource, fla
 		var outline: NavigationPolygon = reading
 		var geometry: NavigationMeshSourceGeometryData2D = NavigationMeshSourceGeometryData2D.new()
 		NavigationServer2D.parse_source_geometry_data(outline, geometry, region)
-		found = geometry.has_data()
+		# has_data() counts only traversable outlines, so a bake carving every obstacle it read would
+		# still say it read nothing.
+		found = (
+			not geometry.get_obstruction_outlines().is_empty()
+			or not geometry.get_projected_obstructions().is_empty()
+		)
 		var polygon: NavigationPolygon = held
 		NavigationServer2D.bake_from_source_geometry_data(polygon, geometry)
 	else:
@@ -215,6 +240,58 @@ static func _why_empty(held: Resource, flat: bool, parsed: bool) -> String:
 	)
 
 
+## Why a 2D bake of [param held] left the whole outline walkable: no obstacle was read, and which
+## nodes of [param scene] that give obstacles are under no region. A tile layer beside the region
+## rather than under it is the usual cause, and the bake alone does not show it.
+static func _nothing_read(scene: GdhSceneFile, held: Resource) -> String:
+	var polygon: NavigationPolygon = held
+	var said: String = (
+		(
+			"No obstacle was read from %s, so all the outlines enclose is walkable, less the "
+			+ "agent_radius %s kept from their edges."
+		)
+		% [
+			_source_said(polygon.source_geometry_mode, polygon.source_geometry_group_name),
+			polygon.agent_radius
+		]
+	)
+	var outside: PackedStringArray = []
+	for node: Node in _all_under(scene.root):
+		var gives: bool = (
+			node is TileMapLayer
+			or node is StaticBody2D
+			or node is MeshInstance2D
+			or node is Polygon2D
+			or node is NavigationObstacle2D
+		)
+		if gives and not _in_a_region(node):
+			var _named: bool = outside.append("%s (a %s)" % [scene.path_of(node), node.get_class()])
+	if outside.is_empty():
+		return said
+	return (
+		(
+			"%s %s %s outside what was read; the bake reads a node elsewhere once it is in the group %s and "
+			+ "source_geometry_mode is groups_with_children, or once it is moved under the region."
+		)
+		% [
+			said,
+			", ".join(outside),
+			"is" if outside.size() == 1 else "are",
+			polygon.source_geometry_group_name,
+		]
+	)
+
+
+## Whether [param node] is under a 2D region, this one or another, whose obstacle it then is.
+static func _in_a_region(node: Node) -> bool:
+	var above: Node = node.get_parent()
+	while above != null:
+		if above is NavigationRegion2D:
+			return true
+		above = above.get_parent()
+	return false
+
+
 static func _source_said(mode: int, group: String) -> String:
 	if mode == 0:
 		return "the region's children (source mode root_node_children)"

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

@@ -470,7 +470,7 @@ func set_theme_color(args: Dictionary) -> Dictionary:
 	return _noting_variation(
 		{
 			"ok": true,
-			"themePath": theme_path,
+			"resourcePath": theme_path,
 			"controlType": control_type,
 			"colorName": color_name,
 			"color": {"r": stored.r, "g": stored.g, "b": stored.b, "a": stored.a}
@@ -524,7 +524,7 @@ func set_theme_font_size(args: Dictionary) -> Dictionary:
 	return _noting_variation(
 		{
 			"ok": true,
-			"themePath": theme_path,
+			"resourcePath": theme_path,
 			"controlType": control_type,
 			"fontSizeName": font_size_name,
 			"size": saved.get_font_size(font_size_name, control_type)
@@ -572,7 +572,7 @@ func remove_theme_item(args: Dictionary) -> Dictionary:
 	var unsaved: String = _save_theme(theme, theme_path, removed)
 	if not unsaved.is_empty():
 		return {"ok": false, "error": unsaved}
-	return {"ok": true, "themePath": theme_path, "controlType": control_type, "removed": removed}
+	return {"ok": true, "resourcePath": theme_path, "controlType": control_type, "removed": removed}
 
 
 ## [param answer] with a note when its controlType names no class a theme styles. Any name is a

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

@@ -204,9 +204,11 @@ static func follow(changed: String, old_path: String, new_path: String, carried:
 			file.close()
 			GdhSceneFile.refresh(scene_path)
 			followed.append(scene_path)
-		if moves.is_empty() or not text.contains("NodePath("):
+		var holds_paths: bool = text.contains("NodePath(")
+		# A script is only read, for the lines naming the node, so it does not need the file written.
+		if moves.is_empty() or not (holds_paths or text.contains('Script"')):
 			continue
-		if not unsaved.is_empty() and not new_path.is_empty():
+		if holds_paths and not unsaved.is_empty() and not new_path.is_empty():
 			not_followed.append({"scenePath": scene_path, "reason": unsaved})
 			continue
 		var before: int = carried.retargeted.size()

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

@@ -15,6 +15,7 @@ const GdhHeadlessCheck = preload("../headless_check.gd")
 const GdhRead = preload("../reading.gd")
 const GdhSceneFile = preload("../scene_file.gd")
 const GdhSceneUids = preload("../scene_uids.gd")
+const GdhScriptPaths = preload("script_paths.gd")
 ## PROPERTY_HINT_NO_NODEPATH, which marks a property the editor's rename skips. It is not bound for
 ## scripts, and follows PROPERTY_HINT_ONESHOT in the engine's list.
 const HINT_NO_NODEPATH: int = PROPERTY_HINT_ONESHOT + 1
@@ -25,6 +26,14 @@ var retargeted: Array[Dictionary] = []
 var not_retargeted: Array[Dictionary] = []
 ## Each path naming a deleted node, or a node below one, which now names nothing.
 var still_naming: Array[Dictionary] = []
+## Each line of a script on a node naming a node that moved or went by the path it had, as
+## {scenePath, nodePath, script, line, from, to}, to absent for a deleted node. Code is left as it
+## was, as the editor's own rename leaves it.
+var scripts_naming: Array[Dictionary] = []
+## The script lines already named, so one shared by an instance and its scene is named once.
+var _lines: Dictionary = {}
+## The paths each script names, by the script, read once however many nodes it is on.
+var _named_in: Dictionary = {}
 ## The files beside a scene holding a rewritten track, each to the resource saved there.
 var _homes: Dictionary = {}
 ## Each track rewritten in an animation one of [member _homes] keeps, as [animation, track, the path
@@ -87,6 +96,7 @@ func carry(scene: GdhSceneFile, moves: Dictionary) -> int:
 		var mixer: AnimationMixer = node as AnimationMixer
 		if mixer != null:
 			_tracks(mixer, now)
+		_scripts(node, was, now)
 	return retargeted.size() - before
 
 
@@ -146,9 +156,45 @@ func answer() -> Dictionary:
 		fields["notRetargeted"] = not_retargeted
 	if not still_naming.is_empty():
 		fields["stillNaming"] = still_naming
+	if not scripts_naming.is_empty():
+		fields["scriptsNaming"] = scripts_naming
 	return fields
 
 
+## Names each line of the scripts on [param node], its own and those it extends, that names from
+## where the node was a node the move took, by the path that no longer reaches it.
+func _scripts(node: Node, was: String, now: String) -> void:
+	var script: Script = node.get_script()
+	while script is GDScript:
+		var file: String = script.resource_path
+		if not _named_in.has(script):
+			var source: String = script.source_code
+			if source.is_empty() and FileAccess.file_exists(file):
+				source = FileAccess.get_file_as_string(file)
+			_named_in[script] = GdhScriptPaths.named(source)
+		var listed: Array[Dictionary] = _named_in[script]
+		for named: Dictionary in listed:
+			var path: String = named["path"]
+			var key: String = "%s:%d:%s" % [file, named["line"], path]
+			if _lines.has(key):
+				continue
+			var after: Array = _after(NodePath(path), was, now)
+			if after[0] == UNCHANGED:
+				continue
+			_lines[key] = true
+			var record: Dictionary = {
+				"scenePath": _scene.path,
+				"nodePath": now,
+				"script": file,
+				"line": named["line"],
+				"from": path,
+			}
+			if after[0] == REWRITTEN:
+				record["to"] = after[1]
+			scripts_naming.append(record)
+		script = script.get_base_script()
+
+
 ## Puts back each track rewritten outside the scene whose record [param matching] takes, or that is
 ## kept in [param file], and answers their records. A file left with none is not saved.
 func _put_back(matching: Callable, file: String = "") -> Array[Dictionary]:
@@ -294,6 +340,8 @@ func _after(path: NodePath, was: String, now: String) -> Array:
 	if holder.get_node_or_null(NodePath(path.get_concatenated_names())) == target:
 		return [UNCHANGED, ""]
 	var to: String = str(holder.get_path_to(target, unique))
+	if unique:
+		to = _unique_to(start, target, to)
 	if path.get_subname_count() > 0:
 		to += ":" + path.get_concatenated_subnames()
 	return [REWRITTEN, to]
@@ -305,6 +353,17 @@ func _names_nothing(path: NodePath, now: String) -> bool:
 	return holder != null and holder.get_node_or_null(NodePath(path.get_concatenated_names())) == null
 
 
+## The path to [param target] through the unique node that was at [param start], written through its
+## unique name as the path being carried was, or [param otherwise] when it is no longer unique. The
+## engine's own unique path is given only from a node with the same owner, so never from the root.
+func _unique_to(start: String, target: Node, otherwise: String) -> String:
+	var through: Node = _scene.root.get_node_or_null(moved(start, _moves))
+	if through == null or not through.unique_name_in_owner:
+		return otherwise
+	var rest: String = str(through.get_path_to(target))
+	return "%" + through.name + ("" if rest == "." else "/" + rest)
+
+
 ## Where the node a path held by the node at [param now] names as %[param name] was: one marked
 ## unique in the same owner that had that name before the move, or a deleted one that had it.
 func _unique_was(name: String, now: String) -> String:

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

@@ -0,0 +1,148 @@
+@tool
+extends RefCounted
+
+## The node paths a GDScript names in its own source, from the node it is on: `$Path`, `%Unique`,
+## and a string handed to get_node, get_node_or_null or has_node called on itself. Read from the
+## tokens rather than the lines, so a `$` or a `%` inside a string or a comment names nothing, and
+## a `%` after an operand is the remainder of a division rather than a unique name.
+
+enum { NAME, STRING, MARK }
+
+## The calls that take a path from the node they are called on.
+const CALLS: Array[String] = ["get_node", "get_node_or_null", "has_node"]
+## The words after which a `%` starts an operand.
+const OPERAND_AFTER: Array[String] = [
+	"return", "and", "or", "not", "in", "if", "elif", "while", "await", "match", "when", "else"
+]
+## The marks after which a `%` starts an operand: an opening bracket, a separator or an operator.
+const OPERAND_AFTER_MARKS: String = "([{,=:;+-*/<>!&|^~%"
+const MARKS: String = "+-*/%<>=!&|^~()[]{},.:;$@?\\"
+const QUOTES: String = "\"'"
+
+
+## Each path [param source] names, as {line, path}: the line it is on, counted from 1, and the path
+## as a NodePath writes it, a unique name with its `%`.
+static func named(source: String) -> Array[Dictionary]:
+	var tokens: Array[Array] = _tokens(source)
+	var found: Array[Dictionary] = []
+	for at: int in tokens.size():
+		var token: Array = tokens[at]
+		var path: String = ""
+		if _is_mark(token, "$"):
+			path = _path_from(tokens, at + 1)
+		elif _is_mark(token, "%") and _starts_operand(tokens, at):
+			path = _path_from(tokens, at)
+		elif token[0] == NAME and CALLS.has(str(token[1])) and _on_itself(tokens, at):
+			if at + 2 < tokens.size() and _is_mark(tokens[at + 1], "(") and tokens[at + 2][0] == STRING:
+				path = str(tokens[at + 2][1])
+		if not path.is_empty():
+			found.append({"line": token[2], "path": path})
+	return found
+
+
+## The path written from [param at]: a string, or names joined by `/`, each a word, `.` or `..`,
+## and any of them a unique name after a `%`. "" when nothing there is a path.
+static func _path_from(tokens: Array[Array], at: int) -> String:
+	if at < tokens.size() and tokens[at][0] == STRING:
+		return str(tokens[at][1])
+	var parts: PackedStringArray = []
+	var more: bool = true
+	while more:
+		var part: Array = _part_at(tokens, at)
+		if part.is_empty():
+			break
+		var _added: bool = parts.append(str(part[0]))
+		at = part[1]
+		more = at + 1 < tokens.size() and _is_mark(tokens[at], "/")
+		at += 1
+	return "/".join(parts)
+
+
+## The name of a path at [param at], as [its text, where the next token is], or [] when there is none.
+static func _part_at(tokens: Array[Array], at: int) -> Array:
+	var unique: String = ""
+	if at < tokens.size() and _is_mark(tokens[at], "%"):
+		unique = "%"
+		at += 1
+	if at >= tokens.size():
+		return []
+	var token: Array = tokens[at]
+	if token[0] == NAME or (unique.is_empty() and _is_mark(token, ".", "..")):
+		return [unique + str(token[1]), at + 1]
+	if token[0] == STRING and not unique.is_empty():
+		return [unique + str(token[1]), at + 1]
+	return []
+
+
+## Whether the `%` at [param at] begins an operand, where after one it is a division's remainder.
+static func _starts_operand(tokens: Array[Array], at: int) -> bool:
+	if at == 0:
+		return true
+	var before: Array = tokens[at - 1]
+	if before[0] == MARK:
+		return OPERAND_AFTER_MARKS.contains(str(before[1]))
+	return before[0] == NAME and OPERAND_AFTER.has(str(before[1]))
+
+
+## Whether the call named at [param at] is made on the script's own node: bare, or on `self`.
+static func _on_itself(tokens: Array[Array], at: int) -> bool:
+	if at == 0 or not _is_mark(tokens[at - 1], "."):
+		return true
+	return at >= 2 and tokens[at - 2][0] == NAME and tokens[at - 2][1] == "self"
+
+
+static func _is_mark(token: Array, mark: String, other: String = "") -> bool:
+	return token[0] == MARK and (token[1] == mark or (not other.is_empty() and token[1] == other))
+
+
+## [param source] as [kind, text, line] tokens, without comments or blank space. A string's text is
+## what is between its quotes, as written.
+static func _tokens(source: String) -> Array[Array]:
+	var tokens: Array[Array] = []
+	var line: int = 1
+	var at: int = 0
+	while at < source.length():
+		var c: String = source[at]
+		var next: String = source[at + 1] if at + 1 < source.length() else ""
+		if c == "\n":
+			line += 1
+			at += 1
+		elif c == "#":
+			while at < source.length() and source[at] != "\n":
+				at += 1
+		elif c in " \t\r":
+			at += 1
+		elif QUOTES.contains(c) or ("r^&".contains(c) and QUOTES.contains(next) and not next.is_empty()):
+			var quoted: Array = _string(source, at if QUOTES.contains(c) else at + 1)
+			tokens.append([STRING, quoted[0], line])
+			line += str(quoted[0]).count("\n")
+			at = quoted[1]
+		elif c == "." and next == ".":
+			tokens.append([MARK, "..", line])
+			at += 2
+		elif MARKS.contains(c):
+			tokens.append([MARK, c, line])
+			at += 1
+		else:
+			var start: int = at
+			at += 1
+			while at < source.length() and not _ends_a_word(source[at]):
+				at += 1
+			tokens.append([NAME, source.substr(start, at - start), line])
+	return tokens
+
+
+## The string whose opening quote is at [param at], as [what is between its quotes, where it ends].
+## A backslash keeps the character after it inside the string, raw or not, as the tokenizer reads it.
+static func _string(source: String, at: int) -> Array:
+	var quote: String = source[at]
+	var closing: String = quote.repeat(3) if source.substr(at, 3) == quote.repeat(3) else quote
+	var start: int = at + closing.length()
+	var end: int = start
+	while end < source.length() and source.substr(end, closing.length()) != closing:
+		end += 2 if source[end] == "\\" else 1
+	return [source.substr(start, end - start), mini(end + closing.length(), source.length())]
+
+
+static func _ends_a_word(c: String) -> bool:
+	return c in " \t\r\n#" or MARKS.contains(c) or QUOTES.contains(c)

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

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

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

@@ -215,7 +215,8 @@ static func offered(said: String, word: String, names: Array) -> String:
 ## [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, or else the
 ## variables its script declares. The engine's own are not listed when none is near, since an object
-## has a hundred, while a script's are the few a caller most likely meant.
+## has a hundred, while a script's are the few a caller most likely meant; an object with no script
+## is told where they are listed instead, since the refusal alone left nothing to try.
 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] = []
@@ -233,8 +234,15 @@ static func near_property(said: String, target: Object, property: String) -> Str
 	var close: PackedStringArray = nearest(property, PackedStringArray(names))
 	if not close.is_empty():
 		return "%s; the nearest it has %s %s" % [said, "is" if close.size() == 1 else "are", ", ".join(close)]
-	if scripted.is_empty():
+	# With a script that declares nothing readable, as one that does not compile, the name is likelier
+	# the script's than the class's, so the class's list would point the wrong way.
+	if scripted.is_empty() and target.get_script() != null:
 		return said
+	if scripted.is_empty():
+		return (
+			"%s; editor_classes info with className %s and includeInherited true lists the ones it has"
+			% [said, target.get_class()]
+		)
 	scripted.sort()
 	return "%s; its script declares %s" % [said, ", ".join(PackedStringArray(scripted))]