gdharness 1.3.8 → 1.3.10

package/build/godot/operations/declared_values.gd

@@ -6,6 +6,36 @@ extends RefCounted
 
 const GdhRead = preload("reading.gd")
 
+## The section of layer_names in project.godot naming the layers of each layers hint.
+const LAYER_NAMES: Dictionary[int, String] = {
+	PROPERTY_HINT_LAYERS_2D_PHYSICS: "2d_physics",
+	PROPERTY_HINT_LAYERS_2D_RENDER: "2d_render",
+	PROPERTY_HINT_LAYERS_2D_NAVIGATION: "2d_navigation",
+	PROPERTY_HINT_LAYERS_3D_PHYSICS: "3d_physics",
+	PROPERTY_HINT_LAYERS_3D_RENDER: "3d_render",
+	PROPERTY_HINT_LAYERS_3D_NAVIGATION: "3d_navigation",
+	PROPERTY_HINT_LAYERS_AVOIDANCE: "avoidance",
+}
+## How many layers a mask holds, one bit each, whatever the editor names.
+const MASK_LAYERS: int = 32
+
+
+## The layers [param mask] holds under a layers [param hint], each with the name project.godot
+## gives it where it gives one.
+static func layers_in(hint: int, mask: int) -> Array[Dictionary]:
+	var layers: Array[Dictionary] = []
+	for layer: int in range(1, MASK_LAYERS + 1):
+		if mask & (1 << (layer - 1)) == 0:
+			continue
+		var entry: Dictionary = {"layer": layer}
+		var name: String = str(
+			ProjectSettings.get_setting("layer_names/%s/layer_%d" % [LAYER_NAMES[hint], layer], "")
+		)
+		if not name.is_empty():
+			entry["name"] = name
+		layers.append(entry)
+	return layers
+
 
 ## 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
@@ -127,6 +157,77 @@ static func enum_refusal(
 	return said + ". The nearest %s %s." % ["is" if close.size() == 1 else "are", ", ".join(close)]
 
 
+## Why [param word], given as argument [param index] of [param called] for the enum [param named],
+## names none of its [param choices].
+static func enum_argument_refusal(
+	called: String, index: int, named: String, word: String, choices: Dictionary
+) -> String:
+	var said: String = (
+		"%s takes the enum %s as argument %d, and %s is none of its values: send %s by name or by number"
+		% [called, named, index + 1, word, _listed(choices)]
+	)
+	var close: PackedStringArray = GdhRead.nearest(word, PackedStringArray(choices.keys()))
+	if close.is_empty():
+		return said + "."
+	return said + ". The nearest %s %s." % ["is" if close.size() == 1 else "are", ", ".join(close)]
+
+
+## Why [param value], given as argument [param index] for the enum [param named], is none of its
+## [param choices], or "" when it is one. The engine passes any number on.
+static func outside_enum_argument(index: int, named: String, value: Variant, choices: Dictionary) -> String:
+	if typeof(value) != TYPE_INT or choices.values().has(value):
+		return ""
+	return (
+		"argument %d, %d, is none of the values %s declares: %s."
+		% [index + 1, value, named, _listed(choices)]
+	)
+
+
+## The values of the enum the engine names [param qualified], by name: an engine class's, as
+## Node.ProcessMode, or a script's, as Named.Size for a class_name, res://main.gd.Mood for a script
+## without one, and either followed by inner classes. {} when it names nothing this can read.
+static func enum_declared_as(qualified: String) -> Dictionary:
+	var cut: int = qualified.rfind(".")
+	if cut <= 0:
+		return {}
+	var owner: String = qualified.substr(0, cut)
+	var named: String = qualified.substr(cut + 1)
+	if ClassDB.class_exists(owner):
+		var constants: Dictionary = {}
+		for constant: String in ClassDB.class_get_enum_constants(owner, named):
+			constants[constant] = ClassDB.class_get_integer_constant(owner, constant)
+		return constants
+	var script: Script = _script_named_as(owner)
+	if script == null:
+		return {}
+	var found: Variant = script.get_script_constant_map().get(named)
+	if not found is Dictionary:
+		return {}
+	var values: Dictionary = found
+	return values
+
+
+## The script [param owner] names: a class_name, a res:// path, or an inner class of either after a
+## dot, or null.
+static func _script_named_as(owner: String) -> Script:
+	var by_name: Script = script_class(owner)
+	if by_name != null:
+		return by_name
+	if owner.begins_with("res://") and ResourceLoader.exists(owner):
+		return load(owner) as Script
+	var cut: int = owner.rfind(".")
+	if cut <= 0:
+		return null
+	var outer: Script = _script_named_as(owner.substr(0, cut))
+	if outer == null:
+		return null
+	var inner: Variant = outer.get_script_constant_map().get(owner.substr(cut + 1))
+	if not inner is Script:
+		return null
+	var inner_script: Script = inner
+	return inner_script
+
+
 ## 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.
@@ -153,6 +254,19 @@ static func outside(target: Object, declared: Dictionary, value: Variant, shown:
 		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_FLAGS and typeof(value) == TYPE_INT:
+		var flags: Dictionary = flags_of(hint_string)
+		var known: int = 0
+		for bit: int in flags.values():
+			known |= bit
+		var whole: int = value
+		var stray: int = whole & ~known
+		if flags.is_empty() or stray == 0:
+			return ""
+		return (
+			"%d holds bits no flag of %s has (%d): its flags are %s; the engine stores it as given."
+			% [whole, property, stray, _listed(flags)]
+		)
 	if hint != PROPERTY_HINT_RANGE:
 		return ""
 	var parts: PackedStringArray = []
@@ -173,6 +287,20 @@ static func outside(target: Object, declared: Dictionary, value: Variant, shown:
 	)
 
 
+## The flags a flags hint names, each with its bit: "Fill:1,Expand:2" gives its values, and a name
+## with none takes the bit of its place, as @export_flags("A", "B") does.
+static func flags_of(hint_string: String) -> Dictionary:
+	var flags: Dictionary = {}
+	var parts: PackedStringArray = hint_string.split(",", false)
+	for index: int in parts.size():
+		var part: String = parts[index].strip_edges()
+		if ":" in part:
+			flags[part.get_slice(":", 0)] = part.get_slice(":", 1).to_int()
+		else:
+			flags[part] = 1 << index
+	return flags
+
+
 static func _listed(choices: Dictionary) -> String:
 	var listed: PackedStringArray = []
 	for name: String in choices:
@@ -291,3 +419,147 @@ static func is_a(value: Object, name: String) -> bool:
 			return true
 		script = script.get_base_script()
 	return false
+
+
+## Whether writing [param name] on [param target] runs code of its script: the script itself, a
+## property it declares, or any property once it takes sets through [code]_set[/code].
+static func runs_script_code(target: Object, name: String) -> bool:
+	var script: Script = target.get_script()
+	if name == "script":
+		return true
+	if script == null:
+		return false
+	for method: Dictionary in script.get_script_method_list():
+		if str(method.get("name", "")) == "_set":
+			return true
+	for declared: Dictionary in script.get_script_property_list():
+		if str(declared.get("name", "")) == name:
+			return true
+	return false
+
+
+## Why [param property] of a [param holder], an [param engine_class], declared as [param declared],
+## holds [param held], as shown, after it was given [param given], the value and how it is shown. A
+## text property with a list of names holds only one of them, and its getter answers its default
+## for any other. A player's bus is one, though the engine fills its list only in the inspector, so
+## the buses are read from the AudioServer, which holds the project's layout; "the engine changed or
+## refused the value" left a caller to guess the bus did not exist.
+static func not_held(
+	holder: String, engine_class: String, property: String, declared: Dictionary, given: Array, held: String
+) -> String:
+	var value: Variant = given[0]
+	var said: String = "%s.%s was given %s and holds %s after it was set" % [holder, property, given[1], held]
+	var type: int = GdhRead.as_int(declared.get("type", TYPE_NIL))
+	var hint: int = GdhRead.as_int(declared.get("hint", PROPERTY_HINT_NONE))
+	if hint in LAYER_NAMES and typeof(value) == TYPE_INT:
+		return (
+			(
+				"%s: it is a mask of the %s layers, one bit each from layer 1 (1) to layer %d (%d), so it "
+				+ "takes 0 to %d and the engine keeps only those bits. Nothing was written."
+			)
+			% [
+				said,
+				LAYER_NAMES[hint],
+				MASK_LAYERS,
+				1 << (MASK_LAYERS - 1),
+				(1 << MASK_LAYERS) - 1,
+			]
+		)
+	var names: PackedStringArray = []
+	if hint == PROPERTY_HINT_ENUM and (type == TYPE_STRING or type == TYPE_STRING_NAME):
+		names = PackedStringArray(enum_values(str(declared.get("hint_string", ""))).keys())
+	var bus: bool = property == "bus" and engine_class.begins_with("AudioStreamPlayer")
+	if bus:
+		names = []
+		for index: int in AudioServer.bus_count:
+			var _added: bool = names.append(AudioServer.get_bus_name(index))
+	if names.is_empty() or names.has(str(value)):
+		return said + ": the engine changed or refused the value, so nothing was written."
+	var close: PackedStringArray = GdhRead.nearest(str(value), names)
+	var nearest: String = (
+		"%s %s" % ["is" if close.size() == 1 else "are", ", ".join(close)] if not close.is_empty() else ""
+	)
+	if bus:
+		# Not "holds Master after it was set": the getter answers the first bus for any name the
+		# layout lacks, and nothing was kept.
+		return (
+			(
+				"%s.bus takes the name of one of the project's audio buses, and %s is none of them, so it "
+				+ "would play on %s; %s. project_info include audio_buses lists them, and "
+				+ "project_settings add_audio_bus adds one. Nothing was written."
+			)
+			% [
+				holder,
+				given[1],
+				AudioServer.get_bus_name(0),
+				"the buses are " + ", ".join(names) if nearest.is_empty() else "the nearest " + nearest
+			]
+		)
+	return (
+		"%s: it takes one of the names it lists, and %s is none of them; %s. Nothing was written."
+		% [
+			said,
+			given[1],
+			"it lists " + ", ".join(names) if nearest.is_empty() else "the nearest it lists " + nearest
+		]
+	)
+
+
+## The sentence naming the children of [param node] that have [param property], or "" when none
+## does. A property of a helper node set on the body it serves, as navigation_layers on the
+## CharacterBody2D rather than its NavigationAgent2D, was refused with the nearest physics layer.
+static func held_by_children(node: Node, property: String) -> String:
+	var root: Node = node.owner if node.owner != null else node
+	var holders: PackedStringArray = []
+	for child: Node in node.get_children():
+		if property in child:
+			var _added: bool = holders.append("%s (a %s)" % [root.get_path_to(child), child.get_class()])
+	if holders.is_empty():
+		return ""
+	if holders.size() == 1:
+		return " The node at %s has it." % holders[0]
+	var last: String = holders[holders.size() - 1]
+	return " The nodes at %s and %s have it." % [", ".join(holders.slice(0, -1)), last]
+
+
+## A sentence for each node path in [param given], by property, that names no node from
+## [param node]. A path is written whatever it names, as the inspector writes one, since the node may
+## be added next; a joint whose node_a named nothing then joined nothing, and no answer said so.
+static func naming_nothing(node: Node, given: Dictionary) -> Dictionary:
+	var said: Dictionary = {}
+	for property: String in given:
+		if "/" in property or ":" in property:
+			continue
+		# What the node holds, since a path given as text is held as text until the engine stores it.
+		var path: Variant = node.get(property)
+		if not path is NodePath:
+			continue
+		var named: NodePath = path
+		if named.is_empty() or node.get_node_or_null(named) != null:
+			continue
+		said[property] = (
+			(
+				"%s names no node from %s. It is written, as the editor writes one, since that node may "
+				+ "be added next; until it is, %s finds nothing."
+			)
+			% [str(named), node.name, property]
+		)
+	return said
+
+
+## Why [param material] has no [param property]: a ShaderMaterial's parameters are its shader's
+## uniforms, so the shader is what lacks one, and "ShaderMaterial has no property" named the
+## material.
+static func no_uniform(material: ShaderMaterial, property: String) -> String:
+	var uniform: String = property.trim_prefix("shader_parameter/")
+	if material.shader == null:
+		return "The ShaderMaterial has no shader, so it has no parameter %s yet; set shader first." % uniform
+	var shader: String = material.shader.resource_path
+	var named: String = shader if not shader.is_empty() else "Its shader"
+	var uniforms: Array = []
+	for entry: Dictionary in material.shader.get_shader_uniform_list():
+		uniforms.append(str(entry["name"]))
+	var said: String = "%s declares no uniform %s, which %s would set" % [named, uniform, property]
+	if uniforms.is_empty():
+		return said + "; it declares no uniforms."
+	return GdhRead.offered(said, uniform, uniforms) + "."

package/build/godot/operations/dependencies.gd

@@ -9,7 +9,13 @@ const GdhResourceFiles = preload("resource_files.gd")
 ## What a reverse search reads unless told otherwise: the resource and code files, and the settings
 ## files that name resources, "godot" for project.godot, "cfg" for plugin.cfg and export_presets.cfg,
 ## and "import" for the sidecars that name import scripts and external materials.
-const DEFAULT_USAGE_KINDS: Array[String] = ["tscn", "tres", "gd", "gdshader", "godot", "cfg", "import"]
+const PROJECT_FILE: String = "res://project.godot"
+const DEFAULT_USAGE_KINDS: Array[String] = [
+	"tscn", "tres", "gd", "gdshader", "gdshaderinc", "godot", "cfg", "import"
+]
+## The files written in the shader language, whose comments are // and /* */ rather than #, which in a
+## shader starts a preprocessor directive.
+const SHADER_KINDS: Array[String] = ["gdshader", "gdshaderinc"]
 ## One string literal of either quote, its contents captured by the one it opened with.
 const STRING_LITERAL: String = "\"((?:[^\"\\\\]|\\\\.)*)\"|'((?:[^'\\\\]|\\\\.)*)'"
 
@@ -19,6 +25,9 @@ const REFERENCE_PATTERNS: Array[String] = [
 	'preload\\("([^"]+)"\\)',
 	'load\\("([^"]+)"\\)',
 	'ext_resource.*path="([^"]+)"',
+	# The shader preprocessor reads a relative include against the including file, and only the bare
+	# res:// form was read, so a shader including its sibling depended on nothing.
+	'#include\\s+"([^"]+)"',
 ]
 
 var _log: GdhLog
@@ -39,11 +48,17 @@ class GdhDependencyWalk:
 	var visited: 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) -> void:
+	func _init(
+		p_max_depth: int, p_include_built_in: bool, p_circular_references: Array, p_counts_beyond: bool = true
+	) -> void:
 		max_depth = p_max_depth
 		include_built_in = p_include_built_in
 		circular_references = p_circular_references
+		counts_beyond = p_counts_beyond
 
 
 func _init(p_log: GdhLog) -> void:
@@ -127,6 +142,10 @@ func missing_references() -> Array[Dictionary]:
 			var naming: Array = missing.get_or_add(path, [])
 			if not file in naming:
 				naming.append(file)
+	for path: String in _named_by_settings():
+		var naming: Array = missing.get_or_add(path, [])
+		if not PROJECT_FILE in naming:
+			naming.append(PROJECT_FILE)
 	# Sorted, since the walk meets files in the order the filesystem lists them, which differs
 	# between platforms.
 	var paths: Array = missing.keys()
@@ -139,6 +158,23 @@ func missing_references() -> Array[Dictionary]:
 	return found
 
 
+## The files project.godot's settings name that are not on disk: an autoload, a registered
+## translation, an icon, an enabled plugin. Not the main scene, which has a check of its own, and
+## the engine reports each of the rest on every boot.
+static func _named_by_settings() -> Array[String]:
+	var named: Array[String] = []
+	for line: String in FileAccess.get_file_as_string(PROJECT_FILE).split("\n"):
+		var held: String = line.strip_edges()
+		if held.begins_with(";") or held.begins_with("run/main_scene="):
+			continue
+		for found: RegExMatch in GdhPatterns.compiled('"\\*?(res://[^"]+)"').search_all(held):
+			var path: String = found.get_string(1)
+			if FileAccess.file_exists(path) or DirAccess.dir_exists_absolute(path):
+				continue
+			named.append(path)
+	return named
+
+
 ## One line for [param entry], one of [method missing_references].
 static func missing_line(entry: Dictionary) -> String:
 	var referring: Array = entry.get("referenced_by", [])
@@ -197,11 +233,18 @@ func find_resource_usages(params: Dictionary) -> Dictionary:
 		var file: FileAccess = FileAccess.open(file_path, FileAccess.READ)
 		if not file:
 			continue
-		var lines: PackedStringArray = file.get_as_text().split("\n")
+		var text: String = file.get_as_text()
 		file.close()
-		# A class is used by name only in code. In a scene or a resource the same word is a node's
-		# name or a caption, and each was counted as a use of the class.
-		var code: bool = file_path.get_extension() in ["gd", "gdshader"]
+		var lines: PackedStringArray = text.split("\n")
+		# A class is used by name only in a script's code. In a scene or a resource the same word is a
+		# node's name or a caption, and each was counted as a use of the class; a shader has no use
+		# for one at all.
+		var code: bool = file_path.get_extension() == "gd"
+		# In a shader # opens a directive, so an #include was answered as a comment, and its
+		# comments are // and /* */.
+		var shader_lines: PackedStringArray = []
+		if file_path.get_extension() in SHADER_KINDS:
+			shader_lines = _shader_code(text).split("\n")
 
 		var references: Array[Dictionary] = []
 		for i: int in range(lines.size()):
@@ -222,6 +265,10 @@ func find_resource_usages(params: Dictionary) -> Dictionary:
 				continue
 			var trimmed: String = line.strip_edges()
 			var kind: String = ""
+			var extra: Dictionary = {}
+			var loaded: String = _loaded_by_uid(line) if trimmed.begins_with("[ext_resource") else ""
+			var written: RegExMatch = GdhPatterns.compiled('path="([^"]+)"').search(line)
+			var written_path: String = "" if written == null else _resolved(written.get_string(1), file_path)
 			# A mention in a comment is not a use, and both were answered as one. The question a
 			# reverse walk is asked is whether anything still uses a class, and a project that
 			# documents itself names its collaborators in `##` links: four references to one class,
@@ -232,8 +279,16 @@ func find_resource_usages(params: Dictionary) -> Dictionary:
 				kind = "doc"
 			elif (code and trimmed.begins_with("#")) or name_in_comment:
 				kind = "comment"
+			elif not shader_lines.is_empty() and not _names_target(shader_lines[i], file_path, target):
+				kind = "comment"
+			elif by_its_path and not loaded.is_empty() and loaded != target["path"]:
+				# The engine loads the file the uid names, so the path written here is used by nothing.
+				kind = "stale_path"
+				extra["loads"] = loaded
 			elif by_its_path:
 				kind = _path_reference_kind(line, file_path)
+				if not loaded.is_empty() and written_path != loaded:
+					extra["stale_path"] = written_path
 			elif by_its_autoload:
 				kind = "autoload"
 			else:
@@ -242,9 +297,11 @@ func find_resource_usages(params: Dictionary) -> Dictionary:
 					if GdhPatterns.without_annotations(line).begins_with("extends ")
 					else "class_name"
 				)
-			references.append({"line": i + 1, "kind": kind, "text": trimmed})
+			var found: Dictionary = {"line": i + 1, "kind": kind, "text": trimmed}
+			found.merge(extra)
+			references.append(found)
 			by_kind[kind] = GdhRead.as_int(by_kind.get(kind, 0)) + 1
-			if kind != "doc" and kind != "comment":
+			if not kind in ["doc", "comment", "stale_path"]:
 				in_code += 1
 
 		if not references.is_empty():
@@ -388,6 +445,8 @@ func _path_reference_kind(line: String, file_path: String) -> String:
 		return "extends"
 	if trimmed.begins_with("[ext_resource"):
 		return "ext_resource"
+	if trimmed.begins_with("#include"):
+		return "include"
 	if "preload(" in trimmed:
 		return "preload"
 	if "load(" in trimmed:
@@ -429,13 +488,10 @@ func _gather_missing(deps: Array[Dictionary], parent: String, into: Dictionary)
 			_gather_missing(deeper, path, into)
 
 
-# A circular entry is not counted: it marks that the entry holding it was reached again, which that
-# entry already counts as one reference.
 func _count_recursive(deps: Array[Dictionary]) -> int:
 	var count: int = 0
 	for dep: Dictionary in deps:
-		if not dep.get("circular", false):
-			count += 1
+		count += 1
 		if dep.has("dependencies"):
 			var deeper: Array[Dictionary] = dep["dependencies"]
 			count += _count_recursive(deeper)
@@ -448,13 +504,6 @@ func _analyze_resource(path: String, current_depth: int, walk: GdhDependencyWalk
 	if current_depth >= walk.max_depth:
 		return deps
 
-	if path in walk.path_stack:
-		var cycle: Array[String] = walk.path_stack.slice(walk.path_stack.find(path))
-		cycle.append(path)
-		if not cycle in walk.circular_references:
-			walk.circular_references.append(cycle)
-		return [{"path": path, "circular": true}]
-
 	# 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.
@@ -476,13 +525,15 @@ func _analyze_resource(path: String, current_depth: int, walk: GdhDependencyWalk
 		# about `["res://addons/x/plugin.cfg"]` was a dependency of every project with the addon.
 		if path.get_extension() == "gd":
 			content = _code_lines(content)
+		elif path.get_extension() in SHADER_KINDS:
+			content = _shader_code(content)
 		var moved: Dictionary = _moved_by_uid(content)
 
 		for pattern: String in REFERENCE_PATTERNS:
 			var regex: RegEx = GdhPatterns.compiled(pattern)
 			for m: RegExMatch in regex.search_all(content):
-				var dep_path: String = _resolved(_referenced_path(m.get_string()), path)
-				dep_path = str(moved.get(dep_path, dep_path))
+				var written: String = _resolved(_referenced_path(m.get_string()), path)
+				var dep_path: String = str(moved.get(written, written))
 
 				if not dep_path.begins_with("res://"):
 					continue
@@ -497,7 +548,14 @@ func _analyze_resource(path: String, current_depth: int, walk: GdhDependencyWalk
 				if not walk.include_built_in and dep_path.begins_with("res://."):
 					continue
 
-				_depend(deps, path, dep_path, {}, current_depth, walk)
+				_depend(
+					deps,
+					path,
+					dep_path,
+					{"stale_path": written} if dep_path != written else {},
+					current_depth,
+					walk
+				)
 
 		# 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 typed a
@@ -518,7 +576,8 @@ func _analyze_resource(path: String, current_depth: int, walk: GdhDependencyWalk
 
 # 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, or empty for a path.
+# 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,
@@ -534,10 +593,27 @@ func _depend(
 			return
 	var dep_info: Dictionary = {"path": dep_path, "exists": 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)
 
 
@@ -611,34 +687,71 @@ static func _resolved(written: String, from: String) -> String:
 	return from.get_base_dir().path_join(written).simplify_path()
 
 
-# The path inside a preload(), load() or ext_resource match; a bare res:// match is the path.
-# The ext_resource paths in [param content] that nothing is at, each with the file its uid names
-# instead. The engine loads an ext_resource by its uid first, 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.
+# 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:
 	var moved: Dictionary = {}
 	for line: RegExMatch in GdhPatterns.compiled("\\[ext_resource[^\\]]*\\]").search_all(content):
-		var entry: String = line.get_string()
-		var at: RegExMatch = GdhPatterns.compiled('path="([^"]+)"').search(entry)
-		var uid: RegExMatch = GdhPatterns.compiled('uid="(uid://[^"]+)"').search(entry)
-		if at == null or uid == null or FileAccess.file_exists(at.get_string(1)):
-			continue
-		var id: int = ResourceUID.text_to_id(uid.get_string(1))
-		if id == ResourceUID.INVALID_ID or not ResourceUID.has_id(id):
-			continue
-		var found: String = ResourceUID.get_id_path(id)
-		if FileAccess.file_exists(found):
+		var found: String = _loaded_by_uid(line.get_string())
+		var at: RegExMatch = GdhPatterns.compiled('path="([^"]+)"').search(line.get_string())
+		if at != null and not found.is_empty() and found != at.get_string(1):
 			moved[at.get_string(1)] = found
 	return moved
 
 
+# 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:
+	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)
+	return found if FileAccess.file_exists(found) else ""
+
+
+# [param content], a shader's code, with its // and /* */ comments emptied and its lines kept, so a
+# path written in one is no include.
+static func _shader_code(content: String) -> String:
+	var kept: Array[String] = []
+	var length: int = content.length()
+	var copied: int = 0
+	var at: int = 0
+	while at < length:
+		var pair: String = content.substr(at, 2)
+		if content[at] == '"':
+			# Stepped over whole, since an include's res:// holds the // that opens a comment.
+			var close: int = content.find('"', at + 1)
+			var line_end: int = content.find("\n", at + 1)
+			var ends: int = close + 1 if close != -1 else length
+			at = line_end if line_end != -1 and line_end < ends else ends
+		elif pair == "//" or pair == "/*":
+			kept.append(content.substr(copied, at - copied))
+			var block: bool = pair == "/*"
+			var close: int = content.find("*/" if block else "\n", at + 2)
+			var resumes: int = length if close == -1 else (close + 2 if block else close)
+			if block:
+				kept.append("\n".repeat(content.substr(at, resumes - at).count("\n")))
+			at = resumes
+			copied = at
+		else:
+			at += 1
+	kept.append(content.substr(copied))
+	return "".join(PackedStringArray(kept))
+
+
+# The path inside a preload(), load(), #include or ext_resource match; a bare res:// match is the path.
+# An ext_resource is read first, since its type or its path can hold the word load.
 func _referenced_path(matched: String) -> String:
 	var expression: String = ""
-	if "preload" in matched or "load" in matched:
-		expression = '"([^"]+)"'
-	elif "ext_resource" in matched:
+	if matched.begins_with("ext_resource"):
 		expression = 'path="([^"]+)"'
+	elif "load" in matched or matched.begins_with("#include"):
+		expression = '"([^"]+)"'
 	else:
 		return matched
 	var inner: RegEx = GdhPatterns.compiled(expression)