gdharness 1.3.44 → 1.3.46

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

@@ -92,6 +92,19 @@ func connect_signal(args: Dictionary) -> Dictionary:
 	if unbinds > 0:
 		callable = callable.unbind(unbinds)
 	var method_found: bool = target.has_method(method_name)
+	if not method_found and (not binds.is_empty() or unbinds > 0):
+		var named_to: String = str(target.name) if target == scene.root else target_node_path
+		return scene.refuse(
+			(
+				(
+					"%s has no method %s, and the engine connects a signal that binds or unbinds "
+					+ "arguments only to a method its target has, so the scene would load without "
+					+ "the connection. Add the method to the target's script first, or connect "
+					+ "without binds and unbinds."
+				)
+				% [named_to, method_name]
+			)
+		)
 	var misfit: String = _misfit(source, signal_name, callable, flags)
 	if not before.is_empty():
 		var held: Callable = before["callable"]
@@ -102,6 +115,7 @@ func connect_signal(args: Dictionary) -> Dictionary:
 
 	var from: String = scene.path_of(source)
 	var to: String = scene.path_of(target)
+	var _replaced: Dictionary = scene.drop_unmade(from, signal_name, to, method_name)
 	var saved: Dictionary = {}
 	var written: Dictionary = scene.write(
 		func(loaded: Node) -> String:
@@ -464,7 +478,11 @@ func disconnect_signal(args: Dictionary) -> Dictionary:
 	# A connection that was never there saved the scene unchanged and answered as removed, so a
 	# typo in either name read as success.
 	var held: Dictionary = _saved(scene.root, from, signal_name, to, method_name)
-	if held.is_empty():
+	# One the engine could not make is in the file alone, and the write drops it.
+	var unmade: Dictionary = scene.drop_unmade(from, signal_name, to, method_name)
+	if held.is_empty() and not unmade.is_empty():
+		held = { "flags": unmade["flags"], "binds": unmade["binds"], "unbinds": unmade["unbinds"] }
+	elif held.is_empty():
 		# The root's path is ".", which before ".method" read as "..method".
 		var said_from: String = str(source.name) if source == scene.root else from
 		var said_to: String = str(target.name) if target == scene.root else to
@@ -492,8 +510,9 @@ func disconnect_signal(args: Dictionary) -> Dictionary:
 				)
 			)
 		)
-	var callable: Callable = held["callable"]
-	source.disconnect(signal_name, callable)
+	if held.has("callable"):
+		var callable: Callable = held["callable"]
+		source.disconnect(signal_name, callable)
 
 	var written: Dictionary = scene.write(
 		func(loaded: Node) -> String:

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

@@ -303,6 +303,13 @@ func set_tilemap_cells(args: Dictionary) -> Dictionary:
 		wanted.append([at, source_id, atlas_coords, alternative])
 		if source_id == -1:
 			erased += 1
+	# An erased cell leaves the layer's data at its next update, which a layer outside the tree
+	# never has, so the pack wrote it as a cell naming no tile, where the editor's save leaves it
+	# out.
+	if layered != null:
+		layered.update_internals()
+	else:
+		single.update_internals()
 
 	var at_path: String = scene.path_of(node)
 	var written: Dictionary = scene.write(

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

@@ -62,6 +62,15 @@ func set_property(params: Dictionary) -> Dictionary:
 			"type": "error",
 			"message": GdhPaths.nothing_there(holder, named, str(reached["called"])),
 		}
+	if GdhPaths.is_constant(holder, named):
+		return {
+			"type": "error",
+			"message":
+			(
+				"%s:%s is a constant its script declares, and a constant cannot be set"
+				% [reached["called"], named]
+			),
+		}
 	var old_value: Variant = GdhPaths.read_under(holder, named)
 	var slot: Dictionary = GdhValues.slot_declared(holder, named)
 	var declared: int = slot["type"]

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

@@ -503,7 +503,7 @@ static func can_read(holder: Variant, named: String) -> bool:
 		var object: Object = holder
 		if not method.is_empty():
 			return call_refused(object, method, "", args.size()).is_empty()
-		return _has_property(object, named)
+		return _has_property(object, named) or not constant_of(object, named).is_empty()
 	return false
 
 
@@ -876,7 +876,7 @@ static func read_under(holder: Variant, named: String) -> Variant:
 	if not method.is_empty():
 		var args: Array = arguments_of(named)["args"]
 		return object.callv(method, args)
-	return object.get(named)
+	return constant_of(object, named)[0] if is_constant(object, named) else object.get(named)
 
 
 ## Where [param named] lands in a list of [param size], or -1 for a step that is not in it.
@@ -1030,3 +1030,30 @@ static func _has_property(holder: Object, named: String) -> bool:
 		if str(entry["name"]) == named:
 			return true
 	return false
+
+
+## The constant [param named] that [param holder]'s script or a script it extends declares, in a
+## list of one, or an empty list. A constant is no property, so the property list never names it,
+## and `get` answers null for one.
+static func constant_of(holder: Variant, named: String) -> Array:
+	if not holder is Object:
+		return []
+	var object: Object = holder
+	var attached: Variant = object.get_script()
+	if not attached is Script:
+		return []
+	var script: Script = attached
+	while script != null:
+		var constants: Dictionary = script.get_script_constant_map()
+		if constants.has(named):
+			return [constants[named]]
+		script = script.get_base_script()
+	return []
+
+
+## Whether [param named] reaches a constant on [param holder] rather than a property.
+static func is_constant(holder: Variant, named: String) -> bool:
+	if not holder is Object:
+		return false
+	var object: Object = holder
+	return not _has_property(object, named) and not constant_of(object, named).is_empty()

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/animation_reads.gd

@@ -11,6 +11,11 @@ const LOOP_MODE_NAMES: Dictionary[int, String] = {
 	Animation.LOOP_LINEAR: "linear",
 	Animation.LOOP_PINGPONG: "pingpong",
 }
+const UPDATE_MODE_NAMES: Dictionary[int, String] = {
+	Animation.UPDATE_CONTINUOUS: "continuous",
+	Animation.UPDATE_DISCRETE: "discrete",
+	Animation.UPDATE_CAPTURE: "capture",
+}
 const TRACK_TYPE_NAMES: Dictionary[int, String] = {
 	Animation.TYPE_VALUE: "property",
 	Animation.TYPE_POSITION_3D: "position_3d",
@@ -166,6 +171,9 @@ static func _track(anim: Animation, track: int, values: GdhSerialisation) -> Dic
 	var property: String = str(path.get_concatenated_subnames())
 	if not property.is_empty():
 		shaped["property"] = property
+	if kind == Animation.TYPE_VALUE:
+		var mode: int = anim.value_track_get_update_mode(track)
+		shaped["update"] = UPDATE_MODE_NAMES.get(mode, str(mode))
 	var keyframes: Array[Dictionary] = []
 	var methods: Dictionary = {}
 	for key: int in anim.track_get_key_count(track):

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/editor_tools.gd

@@ -81,6 +81,8 @@ static func run(params: Dictionary) -> Dictionary:
 		var answered: Dictionary = answer
 		if not GdhSceneFile.also_saved.is_empty():
 			answered["alsoSaved"] = GdhSceneFile.also_saved.duplicate(true)
+		if not GdhSceneFile.unmade_note.is_empty():
+			answered["unmadeConnections"] = GdhSceneFile.unmade_note
 		if not GdhSceneUids.by_path.is_empty():
 			answered["namedByPath"] = (
 				(

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

@@ -96,6 +96,11 @@ static func without_annotations(line: String) -> String:
 # brace opens before the `#` and closes on a later line. Held by a case, since the argument for the
 # difference is not visible from the code and reads like an oversight beside its neighbours.
 static func without_comment(line: String) -> String:
+	var start: int = _comment_start(line)
+	return (line if start == -1 else line.substr(0, start)).strip_edges()
+
+
+static func _comment_start(line: String) -> int:
 	var quote: String = ""
 	for i: int in range(line.length()):
 		var ch: String = line[i]
@@ -104,7 +109,33 @@ static func without_comment(line: String) -> String:
 				quote = ""
 			continue
 		if ch == "#":
-			return line.substr(0, i).strip_edges()
+			return i
 		if ch == '"' or ch == "'":
 			quote = ch
-	return line.strip_edges()
+	return -1
+
+
+## The code in front of each TODO or FIXME comment in [param content], one entry a comment.
+##
+## Read from the comments alone, as the editor highlights them, so `#TODO` counts and the same
+## words inside a string or a multi-line string do not.
+static func noted_work(content: String) -> Array[String]:
+	var noted: Array[String] = []
+	var in_string: bool = false
+	for line: String in content.split("\n"):
+		if in_string:
+			in_string = triple_quotes(line) % 2 == 0
+			continue
+		var start: int = _comment_start(line)
+		var code: String = line if start == -1 else line.substr(0, start)
+		if triple_quotes(code) % 2 == 1:
+			in_string = true
+		elif start != -1 and compiled("^#+\\s*(?:TODO|FIXME)\\b").search(line.substr(start)):
+			noted.append(code.strip_edges())
+	return noted
+
+
+## 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_diagnostics.gd

@@ -5,6 +5,7 @@ const GdhFileWalk = preload("file_walk.gd")
 const GdhImportPipeline = preload("import_pipeline.gd")
 const GdhInputActions = preload("input_actions.gd")
 const GdhLog = preload("logger.gd")
+const GdhPatterns = preload("patterns.gd")
 const GdhRead = preload("reading.gd")
 const GdhSceneConnections = preload("scene_connections.gd")
 const GdhScriptCheck = preload("script_check.gd")
@@ -87,7 +88,7 @@ func get_project_health(params: Dictionary) -> Dictionary:
 				var content: String = file.get_as_text()
 				file.close()
 
-				if "# TODO" in content or "# FIXME" in content:
+				if not GdhPatterns.noted_work(content).is_empty():
 					todo_count += 1
 
 		# Work noted for later, which no script fails on, so said rather than failed. A count of

package/build/godot/operations/project_validation.gd

@@ -8,6 +8,7 @@ const GdhFileWalk = preload("file_walk.gd")
 const GdhImportPipeline = preload("import_pipeline.gd")
 const GdhInputActions = preload("input_actions.gd")
 const GdhLog = preload("logger.gd")
+const GdhPatterns = preload("patterns.gd")
 const GdhRead = preload("reading.gd")
 const GdhSceneConnections = preload("scene_connections.gd")
 const GdhScriptCheck = preload("script_check.gd")
@@ -196,20 +197,21 @@ 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:
 			var content: String = file.get_as_text()
 			file.close()
 
-			if "# TODO" in content or "# FIXME" in content:
+			var noted: Array[String] = GdhPatterns.noted_work(content)
+			if not noted.is_empty():
 				script_issues.append(
 					{ "path": script_path, "issue": "Contains TODO/FIXME comments" }
 				)
-			if "pass # TODO" in content:
+			if "pass" in noted:
 				script_issues.append(
 					{ "path": script_path, "issue": "Contains unimplemented functions" }
 				)
@@ -292,7 +294,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(),