gdharness 1.3.43 → 1.3.45

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

@@ -312,16 +312,25 @@ static func _bare(word: String) -> String:
 	return word.to_lower().replace("_", "").replace(" ", "")
 
 
-## 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.
+## The signals [param object] has that a caller can connect, its own class's first: its script's,
+## as declared, then the engine's from the class down to Object. The engine lists its own from
+## Object down, which puts a Button's pressed after thirty a Control has, and its script's ahead of
+## those, so reversing the whole list put a game's own two signals after twenty-four of the
+## engine's. Names starting with an underscore are the engine's own.
 static func signals_of(object: Object) -> Array:
+	var declared: Array = []
+	var script: Script = object.get_script()
+	if script != null:
+		for entry: Dictionary in script.get_script_signal_list():
+			var name: String = str(entry["name"])
+			if not name.begins_with("_") and not name in declared:
+				declared.append(name)
 	var names: Array = []
 	for entry: Dictionary in object.get_signal_list():
 		var name: String = str(entry["name"])
-		if not name.begins_with("_"):
+		if not name.begins_with("_") and not name in declared:
 			names.push_front(name)
-	return names
+	return declared + names
 
 
 ## [param word] after the article it takes, "an AnimationTree" or "a Node2D".

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

@@ -526,10 +526,27 @@ func unusable_name(parent: Node, child_name: String, moving: Node = null) -> Str
 	if taken != null and taken != moving and taken.get_parent() == parent:
 		# The root by its name, since its path is ".", and ". already has a child" read as a typo.
 		var holder: String = "The root, %s," % parent.name if parent == root else path_of(parent)
-		return "%s already has a child named %s." % [holder, child_name]
+		return (
+			"%s already has a child named %s; %s is free there."
+			% [holder, child_name, _free_name(parent, child_name)]
+		)
 	return ""
 
 
+## The first name after [param taken] that no child of [param parent] has, numbered as Godot numbers
+## a duplicate: Crate2 after Crate, Crate4 after Crate3 when that is taken too. The refusal alone
+## left a caller guessing at a name that might be taken as well.
+static func _free_name(parent: Node, taken: String) -> String:
+	var digits: int = 0
+	while digits < taken.length() and taken[taken.length() - 1 - digits] in "0123456789":
+		digits += 1
+	var base: String = taken.left(taken.length() - digits)
+	var at: int = 2 if digits == 0 else taken.right(digits).to_int() + 1
+	while parent.has_node(NodePath(base + str(at))):
+		at += 1
+	return base + str(at)
+
+
 ## The properties this scene's own file sets on [param node], each with the value the file gives it.
 func set_here(node: Node) -> Dictionary:
 	return set_at(path_of(node))

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

@@ -62,7 +62,7 @@ static func under(prefix: String, values: GdhSerialisation) -> Dictionary:
 		var value: Variant = ProjectSettings.get_setting(name)
 		var described: Dictionary = {
 			"setting": name,
-			"type": type_string(kind),
+			"type": type_named(kind, value),
 			"value": values.serialize_value(value),
 		}
 		# As a single get says it, so a family read can be told apart into what the project sets and
@@ -81,6 +81,47 @@ static func under(prefix: String, values: GdhSerialisation) -> Dictionary:
 	return { "prefix": prefix, "count": found.size(), "settings": found }
 
 
+## The type [param kind] names, with what [param value] holds when it is a typed array or
+## dictionary, as project.godot writes it: a `Dictionary[String, bool]` was answered as Dictionary,
+## which hides what its keys and values must be.
+static func type_named(kind: int, value: Variant) -> String:
+	if kind == TYPE_ARRAY and value is Array:
+		var list: Array = value
+		if list.is_typed():
+			var element: String = _held(
+				list.get_typed_builtin(), list.get_typed_class_name(), list.get_typed_script()
+			)
+			return "Array[%s]" % element
+	elif kind == TYPE_DICTIONARY and value is Dictionary:
+		var table: Dictionary = value
+		if table.is_typed():
+			var key: String = _held(
+				table.get_typed_key_builtin(),
+				table.get_typed_key_class_name(),
+				table.get_typed_key_script()
+			)
+			var held: String = _held(
+				table.get_typed_value_builtin(),
+				table.get_typed_value_class_name(),
+				table.get_typed_value_script()
+			)
+			return "Dictionary[%s, %s]" % [key, held]
+	return type_string(kind)
+
+
+## One side of a typed collection: a built-in type, a class, or a script by its class_name.
+static func _held(builtin: int, named: StringName, script: Variant) -> String:
+	if builtin == TYPE_NIL:
+		return "Variant"
+	if builtin != TYPE_OBJECT:
+		return type_string(builtin)
+	if script is Script:
+		var declared: Script = script
+		if not declared.get_global_name().is_empty():
+			return declared.get_global_name()
+	return str(named)
+
+
 ## The setting [param setting_path] overrides for builds with one feature, as
 ## `application/run/max_fps.mobile` does `application/run/max_fps`, or "" for a plain setting.
 static func override_base(setting_path: String) -> String:

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

@@ -51,7 +51,7 @@ func reload_script(args: Dictionary) -> Dictionary:
 	var asked: String = str(args.get("scriptPath", ""))
 	if asked.is_empty():
 		return { "ok": false, "error": "scriptPath is required" }
-	var path: String = _spelled_as_on_disk(asked)
+	var path: String = _spelled_as_on_disk(asked, {})
 	if not ResourceLoader.exists(path):
 		return { "ok": false, "error": "No script at " + path }
 
@@ -151,8 +151,9 @@ func scripts_behind(args: Dictionary) -> Dictionary:
 		unsaved = EditorInterface.get_script_editor().get_unsaved_files()
 	var behind: Array[String] = []
 	var edited: Array[String] = []
+	var listings: Dictionary = {}
 	for entry: Variant in asked:
-		var path: String = _spelled_as_on_disk(str(entry))
+		var path: String = _spelled_as_on_disk(str(entry), listings)
 		var script: GDScript = ResourceLoader.get_cached_ref(path) as GDScript
 		if script == null:
 			continue
@@ -196,28 +197,46 @@ func _reread_open_tabs(path: String, answer: Dictionary) -> void:
 ## `res://core/rules.gd`, but the editor holds its copy under the spelling on disk, and a load by
 ## another spelling misses that copy and compiles a new one: reloading that answers with a fresh
 ## compile's members and leaves the copy the editor holds as it was.
-static func _spelled_as_on_disk(path: String) -> String:
+##
+## [param listings] keeps each directory's entries for the length of one call that spells many
+## paths. Listed again for every path, a check of the 416 classes of one project listed a folder of
+## eight hundred files twice per class, and held an editor's main thread for close to a minute on a
+## CI runner, with every request behind it waiting.
+static func _spelled_as_on_disk(path: String, listings: Dictionary) -> String:
 	var local: String = ProjectSettings.localize_path(path)
 	if not local.begins_with("res://"):
 		return local
 	var spelled: String = "res://"
 	for step: String in local.trim_prefix("res://").split("/", false):
-		var listing: DirAccess = DirAccess.open(spelled)
-		if listing == null:
+		if not listings.has(spelled):
+			listings[spelled] = _entries_by_spelling(spelled)
+		var entries: Variant = listings[spelled]
+		if entries == null:
 			return local
-		var found: String = ""
-		for entry: String in listing.get_directories() + listing.get_files():
-			if entry == step:
-				found = entry
-				break
-			if found.is_empty() and entry.nocasecmp_to(step) == 0:
-				found = entry
+		var exact: Dictionary = entries[0]
+		var folded: Dictionary = entries[1]
+		var found: String = step if exact.has(step) else str(folded.get(step.to_lower(), ""))
 		if found.is_empty():
 			return local
 		spelled = spelled.path_join(found)
 	return spelled
 
 
+## The entries of [param directory] by their own spelling and by their spelling in lower case, the
+## first of those that fold together winning, or null for a directory that cannot be opened.
+static func _entries_by_spelling(directory: String) -> Variant:
+	var listing: DirAccess = DirAccess.open(directory)
+	if listing == null:
+		return null
+	var exact: Dictionary = {}
+	var folded: Dictionary = {}
+	for entry: String in listing.get_directories() + listing.get_files():
+		exact[entry] = true
+		if not folded.has(entry.to_lower()):
+			folded[entry.to_lower()] = entry
+	return [exact, folded]
+
+
 func _method_names(script: GDScript) -> Array[String]:
 	var names: Array[String] = []
 	for entry: Dictionary in script.get_script_method_list():

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

@@ -312,16 +312,25 @@ static func _bare(word: String) -> String:
 	return word.to_lower().replace("_", "").replace(" ", "")
 
 
-## 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.
+## The signals [param object] has that a caller can connect, its own class's first: its script's,
+## as declared, then the engine's from the class down to Object. The engine lists its own from
+## Object down, which puts a Button's pressed after thirty a Control has, and its script's ahead of
+## those, so reversing the whole list put a game's own two signals after twenty-four of the
+## engine's. Names starting with an underscore are the engine's own.
 static func signals_of(object: Object) -> Array:
+	var declared: Array = []
+	var script: Script = object.get_script()
+	if script != null:
+		for entry: Dictionary in script.get_script_signal_list():
+			var name: String = str(entry["name"])
+			if not name.begins_with("_") and not name in declared:
+				declared.append(name)
 	var names: Array = []
 	for entry: Dictionary in object.get_signal_list():
 		var name: String = str(entry["name"])
-		if not name.begins_with("_"):
+		if not name.begins_with("_") and not name in declared:
 			names.push_front(name)
-	return names
+	return declared + names
 
 
 ## [param word] after the article it takes, "an AnimationTree" or "a Node2D".

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

@@ -395,6 +395,19 @@ static func class_at(root: Node, path: String) -> Dictionary:
 			"type": "error",
 			"message": "No script is at %s to call a static function of." % script_path,
 		}
+	# A script that did not compile loads all the same, with no methods, and the call answered that
+	# it had no such method, which reads as a misspelt name. An abstract script can be instantiated
+	# as far as this asks, so it is not taken for one.
+	var compiled: Script = loaded as Script
+	if not compiled.can_instantiate():
+		return {
+			"type": "error",
+			"message":
+			(
+				"%s did not compile, so none of its functions can be called; script_diagnostics on "
+				+ "it gives the error and its line."
+			) % script_path,
+		}
 	return { "object": loaded, "node": root }
 
 

package/build/godot/operations/dependencies.gd

@@ -36,6 +36,8 @@ var _files: GdhFileWalk = GdhFileWalk.new()
 ## script again made the whole-project answer quadratic in the number of scripts.
 var _classes_declared: Dictionary = {}
 var _classes_read: bool = false
+var _uids_declared: Dictionary = {}
+var _uids_read: bool = false
 
 
 func _init(p_log: GdhLog) -> void:
@@ -158,8 +160,7 @@ func missing_references() -> Array[Dictionary]:
 func _loaded_and_missing(script: String) -> Array[String]:
 	var loaded: Array[String] = []
 	var named: Dictionary = {}
-	for line: String in FileAccess.get_file_as_string(script).split("\n"):
-		var code: String = GdhPatterns.without_comment(line)
+	for code: String in code_by_line(FileAccess.get_file_as_string(script)):
 		if not code.contains("load("):
 			for literal: String in _string_literals(code):
 				named[_resolved(literal, script)] = true
@@ -492,10 +493,32 @@ static func _code_of(line: String) -> String:
 # [param content] with each line's comment taken off and its strings kept, which is where the paths
 # a script loads are written.
 static func _code_lines(content: String) -> String:
-	var kept: Array[String] = []
+	return "\n".join(code_by_line(content))
+
+
+## Each line of [param content] as code: its comment off, and the text of a string running across
+## lines left out. Read as code, a test suite template's example
+## `load("res://folder/my_class.gd")` was a call of a file that does not exist, which made the
+## project invalid.
+static func code_by_line(content: String) -> Array[String]:
+	var lines: Array[String] = []
+	var in_string: bool = false
 	for line: String in content.split("\n"):
-		kept.append(GdhPatterns.without_comment(line))
-	return "\n".join(kept)
+		if in_string:
+			if GdhPatterns.triple_quotes(line) % 2 == 1:
+				in_string = false
+			lines.append("")
+			continue
+		var code: String = GdhPatterns.without_comment(line)
+		if GdhPatterns.triple_quotes(code) % 2 == 1:
+			in_string = true
+			var opened: int = code.find('"""')
+			var apostrophes: int = code.find("'''")
+			if opened < 0 or (apostrophes >= 0 and apostrophes < opened):
+				opened = apostrophes
+			code = code.substr(0, opened)
+		lines.append(code)
+	return lines
 
 
 # The comment on [param line], strings emptied first so a # inside one does not start it.
@@ -578,21 +601,72 @@ func _analyze_resource(
 	path: String, current_depth: int, walk: GdhDependencyWalk
 ) -> Array[Dictionary]:
 	var deps: Array[Dictionary] = []
-
 	if current_depth >= walk.max_depth:
 		return deps
 
-	# Reused only when it was walked with as much depth left as now. A resource first reached deep
-	# in the walk has a list cut short at the limit, and handing that to a nearer reach answered
-	# with a chain that stopped where nothing stopped it.
+	walk.path_stack.append(path)
+	var cut: bool = false
+	for named: Dictionary in _references(path, walk):
+		var dep_info: Dictionary = named.duplicate()
+		cut = _depend(dep_info, current_depth, walk) or cut
+		deps.append(dep_info)
+	walk.path_stack.pop_back()
+
 	var remaining: int = walk.max_depth - current_depth
-	if walk.visited.has(path):
-		var cached: Dictionary = walk.visited[path]
-		if GdhRead.as_int(cached["remaining"]) == remaining:
-			var cached_deps: Array[Dictionary] = cached["deps"]
-			return cached_deps
+	var shown: Dictionary = walk.shown.get(path, {})
+	if shown.is_empty() or remaining > GdhRead.as_int(shown["remaining"]):
+		walk.shown[path] = { "remaining": remaining, "cut": cut }
+	return deps
 
-	walk.path_stack.append(path)
+
+# Walks [param dep_info], one entry of what the file at [param current_depth] names, and answers
+# whether the depth cut short what it shows. Its dependencies are listed at its first entry, which
+# every later one says is above it: listed in full under every file loading it, a game of a
+# hundred scripts typed by class_name answered half a megabyte at depth six and nothing at all
+# unlimited, the tree growing about sixfold a level. A list the depth cut short is listed again
+# where more depth is left, since pointing a nearer reach at it answered a chain that stopped
+# where nothing stopped it. A list is recorded once walked, so what a later entry points at is
+# always above it.
+func _depend(dep_info: Dictionary, current_depth: int, walk: GdhDependencyWalk) -> bool:
+	var dep_path: String = dep_info["path"]
+	# Marked where the reference closing the cycle is. Marked inside the file reached again, the
+	# tree answered that file as a dependency of itself.
+	if dep_path in walk.path_stack:
+		var cycle: Array[String] = walk.path_stack.slice(walk.path_stack.find(dep_path))
+		cycle.append(dep_path)
+		if not cycle in walk.circular_references:
+			walk.circular_references.append(cycle)
+		dep_info["circular"] = true
+		return false
+	if not dep_info["exists"]:
+		return false
+	var named: int = _references(dep_path, walk).size()
+	if named == 0:
+		return false
+	if current_depth + 1 >= walk.max_depth:
+		# A file the depth stopped at read the same as one naming nothing, and a missing file past
+		# it went unsaid.
+		dep_info["beyond_depth"] = named
+		return true
+	var shown: Dictionary = walk.shown.get(dep_path, {})
+	if not shown.is_empty():
+		var shown_cut: bool = shown["cut"]
+		var remaining: int = walk.max_depth - current_depth - 1
+		if not shown_cut or remaining <= GdhRead.as_int(shown["remaining"]):
+			dep_info["dependencies_listed_above"] = true
+			return shown_cut
+	dep_info["dependencies"] = _analyze_resource(dep_path, current_depth + 1, walk)
+	var walked: Dictionary = walk.shown[dep_path]
+	return walked["cut"]
+
+
+## What [param path] names, each file once, as the entries the tree lists it by; read once a walk.
+func _references(path: String, walk: GdhDependencyWalk) -> Array[Dictionary]:
+	if walk.references.has(path):
+		var known: Array[Dictionary] = walk.references[path]
+		return known
+	var deps: Array[Dictionary] = []
+	walk.references[path] = deps
 
 	var file: FileAccess = FileAccess.open(path, FileAccess.READ)
 	if file:
@@ -619,7 +693,7 @@ func _analyze_resource(
 				# as no res:// path, a script's load of one went unsaid while the game printed
 				# "Unrecognized UID" at that line.
 				if dep_path.begins_with("uid://"):
-					_depend(deps, path, dep_path, {}, current_depth, walk)
+					_name(deps, path, dep_path, {})
 					continue
 				if not dep_path.begins_with("res://"):
 					continue
@@ -638,7 +712,7 @@ func _analyze_resource(
 				var named_by: Dictionary = { "stale_path": written } if dep_path != written else {}
 				if unknown.has(dep_path):
 					named_by["unknown_uid"] = unknown[dep_path]
-				_depend(deps, path, dep_path, named_by, current_depth, walk)
+				_name(deps, path, dep_path, named_by)
 
 		# A script uses another by its class_name as surely as by a preload, and only the reverse
 		# walk looked for that: asked what a script depends on, the answer left out the script it
@@ -647,30 +721,18 @@ func _analyze_resource(
 		if path.get_extension() == "gd":
 			var classes: Dictionary = classes_declared()
 			for used: String in classes_used_in(content, classes):
-				_depend(deps, path, str(classes[used]), { "by_class": used }, current_depth, walk)
+				_name(deps, path, str(classes[used]), { "by_class": used })
 			var autoloads: Dictionary = autoloads_declared()
 			for used: String in classes_used_in(content, autoloads):
-				_depend(
-					deps, path, str(autoloads[used]), { "by_autoload": used }, current_depth, walk
-				)
-
-	walk.path_stack.pop_back()
-	walk.visited[path] = { "deps": deps, "remaining": remaining }
+				_name(deps, path, str(autoloads[used]), { "by_autoload": used })
 	return deps
 
 
-# Adds [param dep_path] to [param deps], what [param path] depends on, walked as far as the depth
-# left allows, once however many times it is named. [param named_by] is the class or autoload name
-# it was named by, as by_class or by_autoload, and the path written when the engine loads another,
-# as stale_path; empty for a path that is the file.
-func _depend(
-	deps: Array[Dictionary],
-	path: String,
-	dep_path: String,
-	named_by: Dictionary,
-	current_depth: int,
-	walk: GdhDependencyWalk
-) -> void:
+# Adds [param dep_path] to [param deps], what [param path] depends on, once however many times it
+# is named. [param named_by] is the class or autoload name it was named by, as by_class or
+# by_autoload, and the path written when the engine loads another, as stale_path; empty for a path
+# that is the file.
+func _name(deps: Array[Dictionary], path: String, dep_path: String, named_by: Dictionary) -> void:
 	if dep_path == path:
 		return
 	for existing: Dictionary in deps:
@@ -683,33 +745,12 @@ func _depend(
 		"exists": not dep_path.begins_with("uid://") and FileAccess.file_exists(dep_path),
 	}
 	dep_info.merge(named_by)
-	# Marked where the reference closing the cycle is. Marked inside the file reached again, the
-	# tree answered that file as a dependency of itself.
-	if dep_path in walk.path_stack:
-		var cycle: Array[String] = walk.path_stack.slice(walk.path_stack.find(dep_path))
-		cycle.append(dep_path)
-		if not cycle in walk.circular_references:
-			walk.circular_references.append(cycle)
-		dep_info["circular"] = true
-		deps.append(dep_info)
-		return
-	if dep_info["exists"] and current_depth + 1 < walk.max_depth:
-		var sub_deps: Array[Dictionary] = _analyze_resource(dep_path, current_depth + 1, walk)
-		if sub_deps.size() > 0:
-			dep_info["dependencies"] = sub_deps
-	elif dep_info["exists"] and walk.counts_beyond:
-		# A file the depth stopped at read the same as one naming nothing, and a missing file past
-		# it went unsaid.
-		var beyond: GdhDependencyWalk = GdhDependencyWalk.new(1, walk.include_built_in, [], false)
-		var named: int = _analyze_resource(dep_path, 0, beyond).size()
-		if named > 0:
-			dep_info["beyond_depth"] = named
 	deps.append(dep_info)
 
 
 ## Every autoload the project registers as a global name, with its script. One that is not global
 ## is no name code can use.
-static func autoloads_declared() -> Dictionary:
+func autoloads_declared() -> Dictionary:
 	var autoloads: Dictionary = {}
 	for property: Dictionary in ProjectSettings.get_property_list():
 		var setting: String = str(property.get("name", ""))
@@ -762,27 +803,63 @@ static func classes_used_in(content: String, classes: Dictionary) -> Array[Strin
 	return used
 
 
-# [param written] as the res:// path the engine would load from [param from]: a uid:// by what the
-# project's uid cache says it names, and a relative path against the referring file's directory.
-# Both were passed over as not being res:// paths, so a script's `preload("sibling.gd")` was no
-# dependency at all.
-static func _resolved(written: String, from: String) -> String:
+# [param written] as the res:// path the engine would load from [param from]: a uid:// by the file
+# it names, and a relative path against the referring file's directory. Both were passed over as not
+# being res:// paths, so a script's `preload("sibling.gd")` was no dependency at all.
+func _resolved(written: String, from: String) -> String:
 	if written.begins_with("res://"):
 		return written
 	if written.begins_with("uid://"):
-		var id: int = ResourceUID.text_to_id(written)
-		return ResourceUID.get_id_path(id) if ResourceUID.has_id(id) else written
+		var found: String = _uid_path(written)
+		return written if found.is_empty() else found
 	if written.contains("://"):
 		return written
 	return from.get_base_dir().path_join(written).simplify_path()
 
 
+# The file the uid:// [param text] names, or empty when nothing does: the engine's uid cache first,
+# then the uids the project's files declare. Only an import writes the cache, so on a fresh clone
+# every uid was answered as naming no file, and a scene moved outside the editor was missing under
+# its old path, although the first import loads it by its uid. A cached path with no file there
+# gives way to a file declaring the uid, and is the answer when none does.
+func _uid_path(text: String) -> String:
+	var id: int = ResourceUID.text_to_id(text)
+	if id == ResourceUID.INVALID_ID:
+		return ""
+	var cached: String = ResourceUID.get_id_path(id) if ResourceUID.has_id(id) else ""
+	if FileAccess.file_exists(cached):
+		return cached
+	return str(_files_by_uid().get(id, cached))
+
+
+# Every file of the project that declares a uid, by its uid's id: in a .uid sidecar, an import
+# sidecar or the header of a text resource, as GdhResourceFiles reads them. Read once for the call,
+# the first time the cache does not know a uid.
+func _files_by_uid() -> Dictionary:
+	if _uids_read:
+		return _uids_declared
+	_uids_read = true
+	var declaring: Dictionary = {}
+	for file: String in _files.find_files_with_extensions(
+		"res://", ["uid", "import"] + GdhResourceFiles.TEXT_RESOURCE_KINDS
+	):
+		var sidecar: bool = file.get_extension() in ["uid", "import"]
+		declaring[file.get_basename() if sidecar else file] = true
+	for file: String in declaring:
+		if not FileAccess.file_exists(file):
+			continue
+		var id: int = ResourceUID.text_to_id(str(GdhResourceFiles.uid_of(file).get("uid", "")))
+		if id != ResourceUID.INVALID_ID:
+			_uids_declared[id] = file
+	return _uids_declared
+
+
 # The ext_resource paths in [param content] whose uid leads elsewhere, each with the file the uid
 # names. The engine loads an ext_resource by its uid whenever the uid is known, whatever the path
 # says, so a file moved outside the editor still loads, and the walk called it missing; every
 # pattern reads the old path, the bare res:// one included, so the paths are mapped before any of
 # them runs.
-static func _moved_by_uid(content: String) -> Dictionary:
+func _moved_by_uid(content: String) -> Dictionary:
 	var moved: Dictionary = {}
 	for line: RegExMatch in GdhPatterns.compiled("\\[ext_resource[^\\]]*\\]").search_all(content):
 		var found: String = _loaded_by_uid(line.get_string())
@@ -795,7 +872,7 @@ static func _moved_by_uid(content: String) -> Dictionary:
 # The ext_resource paths in [param content], read from [param from], whose uid names no file the
 # project has, each with that uid. The engine warns that the uid is invalid and loads the path, and
 # the walk followed the path saying nothing, so an export was the first to mention it.
-static func _unknown_uids(content: String, from: String) -> Dictionary:
+func _unknown_uids(content: String, from: String) -> Dictionary:
 	var unknown: Dictionary = {}
 	for line: RegExMatch in GdhPatterns.compiled("\\[ext_resource[^\\]]*\\]").search_all(content):
 		var uid: String = _unknown_uid_of(line.get_string())
@@ -806,21 +883,18 @@ static func _unknown_uids(content: String, from: String) -> Dictionary:
 
 
 # The uid an ext_resource [param entry] carries when it names no file the project has, or empty.
-static func _unknown_uid_of(entry: String) -> String:
+func _unknown_uid_of(entry: String) -> String:
 	var uid: RegExMatch = GdhPatterns.compiled('uid="(uid://[^"]+)"').search(entry)
 	return "" if uid == null or not _loaded_by_uid(entry).is_empty() else uid.get_string(1)
 
 
 # The file an ext_resource [param entry] is loaded from by its uid, or empty when it carries none
 # the project knows, and the engine falls back to the path.
-static func _loaded_by_uid(entry: String) -> String:
+func _loaded_by_uid(entry: String) -> String:
 	var uid: RegExMatch = GdhPatterns.compiled('uid="(uid://[^"]+)"').search(entry)
 	if uid == null:
 		return ""
-	var id: int = ResourceUID.text_to_id(uid.get_string(1))
-	if id == ResourceUID.INVALID_ID or not ResourceUID.has_id(id):
-		return ""
-	var found: String = ResourceUID.get_id_path(id)
+	var found: String = _uid_path(uid.get_string(1))
 	return found if FileAccess.file_exists(found) else ""
 
 
@@ -877,23 +951,18 @@ class GdhDependencyWalk:
 
 	var include_built_in: bool
 
-	var visited: Dictionary = {}
+	## What each file read names, by its path.
+	var references: Dictionary = {}
+
+	## For each file whose dependencies the tree lists, the depth left where they are listed and
+	## whether the depth cut that list short.
+	var shown: Dictionary = {}
 
 	var path_stack: Array[String] = []
 
 	var circular_references: Array
 
-	## Whether a file the depth stops at is read for how many files it names, which the walk doing
-	## that reading does not do again for those.
-	var counts_beyond: bool
-
-	func _init(
-		p_max_depth: int,
-		p_include_built_in: bool,
-		p_circular_references: Array,
-		p_counts_beyond: bool = true
-	) -> void:
+	func _init(p_max_depth: int, p_include_built_in: bool, p_circular_references: Array) -> void:
 		max_depth = p_max_depth
 		include_built_in = p_include_built_in
 		circular_references = p_circular_references
-		counts_beyond = p_counts_beyond

package/build/godot/operations/editor_tools.gd

@@ -85,15 +85,16 @@ static func run(params: Dictionary) -> Dictionary:
 			answered["namedByPath"] = (
 				(
 					"What this saved names %s by path rather than by uid, which loads the same. A "
-					+ "uid in a file's own header is resolved through the project's uid cache, "
-					+ "which holds none for %s yet, as with a file made since the project was last "
-					+ "scanned, so a uid written now would warn on every load. project_import "
-					+ "refresh_uids scans the project, and writes after it name %s by uid."
+					+ "reference by uid is resolved through the project's uid cache, which holds "
+					+ "none for %s yet, as with a file made since the project was last scanned, so "
+					+ "naming %s by uid now would warn on every load. project_import refresh_uids "
+					+ "scans the project, and writes after it name %s by uid."
 				)
 				% [
 					", ".join(GdhSceneUids.by_path),
 					"it" if GdhSceneUids.by_path.size() == 1 else "them",
 					"it" if GdhSceneUids.by_path.size() == 1 else "them",
+					"it" if GdhSceneUids.by_path.size() == 1 else "them",
 				]
 			)
 		return answered