gdharness 1.3.44 → 1.3.45

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_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

@@ -160,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
@@ -494,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.
@@ -580,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:
@@ -621,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
@@ -640,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
@@ -649,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:
@@ -685,27 +745,6 @@ 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)
 
 
@@ -912,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/gdscript_analysis.gd

@@ -56,6 +56,25 @@ func get_gdscript_info(params: Dictionary) -> Dictionary:
 	# its first function would otherwise be judged against the default.
 	_mark_virtuals(functions, extends_name, full_script_path)
 
+	# The engine loads a base named by its path and a constant handed to load or preload as surely
+	# as a path written in the call, and both were left out while project_dependencies named them: a
+	# script extending "frame.gd" did not depend on it, nor one calling load(TYPE_CASE).
+	for written: String in _based_on_paths(extends_name, own.inner_classes):
+		if not written in dependencies:
+			dependencies.append(written)
+	var held: Dictionary = {}
+	for constant: Dictionary in own.constants:
+		held[str(constant.get("name", ""))] = _unquoted(str(constant.get("value", "")))
+	for code: String in GdhDependencies.code_by_line(content):
+		for loading: RegExMatch in (
+			GdhPatterns
+			. compiled("(?<![\\w.])(?:preload|load)\\s*\\(\\s*([A-Za-z_]\\w*)\\s*\\)")
+			. search_all(code)
+		):
+			var written: String = str(held.get(loading.get_string(1), ""))
+			if not written.is_empty() and not written in dependencies:
+				dependencies.append(written)
+
 	# A script typed by its class_name is depended on as surely as one preloaded, and the answer
 	# listed only the preloads: a `var stats: Stats` left stats.gd out, while project_dependencies
 	# named it. The same reading as that tool's, so the two agree.
@@ -131,7 +150,7 @@ func _members(
 		# Inside a string the raw line is counted, because a `#` in it is text and taking it for a
 		# comment would cut off the quotes that close the string.
 		if in_multiline_string:
-			if _triple_quotes(raw) % 2 == 1:
+			if GdhPatterns.triple_quotes(raw) % 2 == 1:
 				in_multiline_string = false
 			continue
 		# A `##` block documents what it sits directly above: the class when that is its class_name
@@ -165,7 +184,7 @@ func _members(
 		# it opened on. Toggling on any count lost `const HELP := """Usage"""`, and everything after
 		# it up to the next triple quote, with the state inverted from there to the end of the file.
 		# The line that opens one is still read: it can be the declaration the string belongs to.
-		if _triple_quotes(stripped) % 2 == 1:
+		if GdhPatterns.triple_quotes(stripped) % 2 == 1:
 			in_multiline_string = true
 
 		# Only a line at this body's own margin declares one of its members. Deeper, it is a
@@ -207,7 +226,7 @@ func _members(
 			while i + 1 < lines.size():
 				i += 1
 				stripped += "\n" + lines[i]
-				if _triple_quotes(lines[i]) % 2 == 1:
+				if GdhPatterns.triple_quotes(lines[i]) % 2 == 1:
 					break
 			in_multiline_string = false
 			header = GdhPatterns.without_annotations(stripped)
@@ -821,13 +840,31 @@ func _collect_dependencies(line: String, into: Array[String]) -> void:
 			into.append(dep)
 
 
-# How many triple quotes of either kind [param line] holds.
-static func _declares_variable(header: String) -> bool:
-	return header.begins_with("var ") or header.begins_with("static var ")
+## The paths a script and its inner classes extend by, as written: [param extends_name] the
+## script's own extends, and [param inner_classes] its inner classes as answered.
+static func _based_on_paths(extends_name: String, inner_classes: Array) -> Array[String]:
+	var paths: Array[String] = []
+	var written: String = _unquoted(extends_name)
+	if not written.is_empty():
+		paths.append(written)
+	for inner: Dictionary in inner_classes:
+		var deeper: Array = inner.get("inner_classes", [])
+		for path: String in _based_on_paths(str(inner.get("extends", "")), deeper):
+			if not path in paths:
+				paths.append(path)
+	return paths
+
+
+## The text of [param literal], a string literal as written; empty for anything else.
+static func _unquoted(literal: String) -> String:
+	var text: String = literal.strip_edges()
+	if text.length() >= 2 and text[0] in ["\"", "'"] and text[-1] == text[0]:
+		return text.substr(1, text.length() - 2)
+	return ""
 
 
-static func _triple_quotes(line: String) -> int:
-	return line.count('"""') + line.count("'''")
+static func _declares_variable(header: String) -> bool:
+	return header.begins_with("var ") or header.begins_with("static var ")
 
 
 func _extract_dependencies(line: String) -> Array[String]:

package/build/godot/operations/patterns.gd

@@ -108,3 +108,9 @@ static func without_comment(line: String) -> String:
 		if ch == '"' or ch == "'":
 			quote = ch
 	return line.strip_edges()
+
+
+## How many triple quotes of either kind [param line] holds. An odd count opens or closes a string
+## that runs across lines.
+static func triple_quotes(line: String) -> int:
+	return line.count('"""') + line.count("'''")

package/build/godot/operations/project_validation.gd

@@ -196,9 +196,9 @@ func validate_project(params: Dictionary) -> Dictionary:
 	var scripts_checked: int = 0
 	var script_issues: Array[Dictionary] = []
 
-	# A hundred scripts is enough to say whether the project is tidy without a large one
-	# turning validation into a full read of its source tree.
-	for script_path: String in script_files.slice(0, 100):
+	# Every script, as health reads them: cut at the first hundred in walk order, the count sat
+	# beside a compile check of all 803 scripts of a game and read as how many were compiled.
+	for script_path: String in script_files:
 		scripts_checked += 1
 		var file: FileAccess = FileAccess.open(script_path, FileAccess.READ)
 		if file:
@@ -292,7 +292,6 @@ func validate_project(params: Dictionary) -> Dictionary:
 		"warnings": warnings,
 		"checks_performed": checks_performed,
 		"scripts_checked": scripts_checked,
-		# Said beside the count, so a project of four hundred scripts is not read as checked whole.
 		"scripts_total": script_files.size(),
 		"issue_count": issues.size(),
 		"warning_count": warnings.size(),

package/build/godot/operations/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdharness",
-  "version": "1.3.44",
+  "version": "1.3.45",
   "mcpName": "io.github.Aureliolo/gdharness",
   "description": "A harness for driving a Godot 4 project from an agent: editor addons, a runtime bridge into the running game, an MCP server in front of them, and a CLI that installs and diagnoses the Godot side.",
   "type": "module",