gdharness 0.13.30 → 0.13.32

package/build/godot/operations/class_cache.gd

@@ -130,9 +130,6 @@ func _header_of(path: String) -> Dictionary:
 	if not file:
 		return header
 	var annotation: RegEx = Patterns.compiled('^@([a-z_]+)(?:\\(\\s*(?:"([^"]*)")?[^)]*\\))?\\s*')
-	var class_line: RegEx = Patterns.compiled(
-		"^class_name\\s+([A-Za-z_][A-Za-z0-9_]*)(?:\\s+extends\\s+(\\S+))?"
-	)
 	var extends_line: RegEx = Patterns.compiled("^extends\\s+(\\S+)")
 	while not file.eof_reached():
 		var rest: String = file.get_line().strip_edges()
@@ -151,7 +148,7 @@ func _header_of(path: String) -> Dictionary:
 		if rest.is_empty() or rest.begins_with("#"):
 			continue
 		if rest.begins_with("class_name"):
-			var declared: RegExMatch = class_line.search(rest)
+			var declared: RegExMatch = Patterns.declared_class(rest)
 			if declared != null:
 				header["class_name"] = declared.get_string(1)
 				if not declared.get_string(2).is_empty():

package/build/godot/operations/dependencies.gd

@@ -128,6 +128,7 @@ func find_resource_usages(params: Dictionary) -> Dictionary:
 	var usages: Array[Dictionary] = []
 	var by_kind: Dictionary = {}
 	var total: int = 0
+	var in_code: int = 0
 
 	for file_path: String in all_files:
 		if file_path == resource_path:
@@ -141,15 +142,32 @@ func find_resource_usages(params: Dictionary) -> Dictionary:
 		var references: Array[Dictionary] = []
 		for i: int in range(lines.size()):
 			var line: String = lines[i]
+			var by_its_path: bool = by_path.search(line) != null
+			var by_its_name: bool = not by_its_path and by_class != null and by_class.search(line) != null
+			if not by_its_path and not by_its_name:
+				continue
+			var trimmed: String = line.strip_edges()
 			var kind: String = ""
-			if by_path.search(line) != null:
+			# 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,
+			# three of them prose, all counted as code. The more carefully a project is documented
+			# the worse that ratio gets. `##` and `#` are kept apart because renaming the class
+			# breaks Godot's generated documentation and leaves the prose merely stale.
+			if trimmed.begins_with("##"):
+				kind = "doc"
+			elif trimmed.begins_with("#"):
+				kind = "comment"
+			elif by_its_path:
 				kind = _path_reference_kind(line)
-			elif by_class != null and by_class.search(line) != null:
-				kind = "extends" if line.strip_edges().begins_with("extends ") else "class_name"
-			if kind.is_empty():
-				continue
-			references.append({"line": i + 1, "kind": kind, "text": line.strip_edges()})
+			else:
+				kind = (
+					"extends" if Patterns.without_annotations(line).begins_with("extends ") else "class_name"
+				)
+			references.append({"line": i + 1, "kind": kind, "text": trimmed})
 			by_kind[kind] = Read.as_int(by_kind.get(kind, 0)) + 1
+			if kind != "doc" and kind != "comment":
+				in_code += 1
 
 		if not references.is_empty():
 			usages.append({"file": file_path, "references": references})
@@ -167,6 +185,9 @@ func find_resource_usages(params: Dictionary) -> Dictionary:
 			"files_searched": all_files.size(),
 			"files_with_usages": usages.size(),
 			"total": total,
+			# The arithmetic done here rather than left to the caller, because the caller who most
+			# needs it is the one asking whether a class is dead, and that caller reads one number.
+			"in_code": in_code,
 			"by_kind": by_kind,
 		},
 	}
@@ -179,9 +200,9 @@ func _declared_class_name(path: String) -> String:
 	var file: FileAccess = FileAccess.open(path, FileAccess.READ)
 	if not file:
 		return ""
-	var declaration: RegEx = Patterns.compiled("^class_name\\s+([A-Za-z_][A-Za-z0-9_]*)")
 	while not file.eof_reached():
-		var found: RegExMatch = declaration.search(file.get_line())
+		# Annotations first, since `@abstract class_name X` is one line and this read it as none.
+		var found: RegExMatch = Patterns.declared_class(Patterns.without_annotations(file.get_line()))
 		if found != null:
 			file.close()
 			return found.get_string(1)
@@ -191,7 +212,7 @@ func _declared_class_name(path: String) -> String:
 
 # How a line that names the resource by path uses it.
 func _path_reference_kind(line: String) -> String:
-	var trimmed: String = line.strip_edges()
+	var trimmed: String = Patterns.without_annotations(line)
 	if trimmed.begins_with("extends "):
 		return "extends"
 	if trimmed.begins_with("[ext_resource"):

package/build/godot/operations/gdscript_analysis.gd

@@ -1,6 +1,7 @@
 extends RefCounted
 
 const Patterns = preload("patterns.gd")
+const Read = preload("reading.gd")
 const Log = preload("logger.gd")
 
 var _log: Log
@@ -44,10 +45,16 @@ func get_gdscript_info(params: Dictionary) -> Dictionary:
 
 	var in_multiline_string: bool = false
 
-	for i: int in range(lines.size()):
-		var stripped: String = lines[i].strip_edges()
+	var i: int = -1
+	while i + 1 < lines.size():
+		i += 1
+		# The comment off first, so nothing downstream has to know about them. It was reaching the
+		# answer: a `var x: int = 5  # note` carried `5  # note` as its default, and correcting the
+		# end of a parameter list put the comment into the return type, where `rfind(")")` had been
+		# hiding it by stopping inside the comment instead.
+		var stripped: String = _without_comment(lines[i])
 
-		if stripped.is_empty() or stripped.begins_with("#"):
+		if stripped.is_empty():
 			continue
 
 		if '"""' in stripped or "'''" in stripped:
@@ -57,33 +64,68 @@ func get_gdscript_info(params: Dictionary) -> Dictionary:
 		if in_multiline_string:
 			continue
 
-		if stripped.begins_with("class_name "):
-			declared_class_name = stripped.substr(11).strip_edges()
-		elif stripped.begins_with("extends "):
-			extends_name = stripped.substr(8).strip_edges()
-		elif stripped.begins_with("signal "):
-			signals.append(_parse_signal(stripped, i + 1))
-		elif stripped.begins_with("const "):
-			constants.append(_parse_constant(stripped, i + 1))
-		elif stripped.begins_with("enum "):
-			enums.append(_parse_enum(stripped, i + 1))
-		elif (
-			stripped.begins_with("var ")
-			or stripped.begins_with("@export")
-			or stripped.begins_with("@onready")
-		):
-			variables.append(_parse_variable(stripped, i + 1))
-		elif stripped.begins_with("func ") or stripped.begins_with("static func "):
-			functions.append(_parse_function(stripped, i + 1))
-		elif stripped.begins_with("class "):
-			inner_classes.append(stripped.substr(6).split(":")[0].split(" ")[0].strip_edges())
+		# Annotations may share the line with anything they annotate, so every branch below decides
+		# on the line with them off. `@abstract class_name X` was reported as no declared class,
+		# and `@abstract func x()` and `@warning_ignore("...") func x()` as no function at all:
+		# gdUnit4 alone declares 248 methods that way and this answered with none of them.
+		var header: String = Patterns.without_annotations(stripped)
+
+		var at: int = i
+		# A declaration wrapped across lines is one declaration, and reading the first line alone
+		# answered with the half that was not wrapped away: `values: []` for every `enum X {` on its
+		# own line and `params: []` with no return type for every `func x(`. `gdformat` wraps
+		# anything past the line length, so that is what a formatted project looks like: 23 and 19
+		# of them in gdUnit4 v6.2.1, 55 in one game project, and four in this addon.
+		#
+		# Only a declaration, because an unbalanced line anywhere else is a file mid-edit and
+		# joining from one swallows the rest of it: a body holding `print(` with nothing closing it
+		# took every declaration below it, which is the state an agent is most likely to ask about.
+		# `header` rather than `stripped`: an annotation in front pushes the keyword off the start
+		# of the line, so asking the raw line whether it can wrap says no to every annotated
+		# declaration that does. Held by the combined case, which nothing else in the fixture
+		# reaches: the single-feature cases each carry one of these and never a second.
+		if _can_wrap(header):
+			while _bracket_depth(stripped) > 0 and i + 1 < lines.size():
+				i += 1
+				stripped = (stripped + " " + _without_comment(lines[i])).strip_edges()
+			header = Patterns.without_annotations(stripped)
+		var declaration: RegExMatch = Patterns.declared_class(header)
+		if declaration != null:
+			declared_class_name = declaration.get_string(1)
+			# `class_name X extends Y` is also one line, and taking the rest of it as the name
+			# reported `Blade extends Node2D` as the class while `extends` kept its default of
+			# `RefCounted`: the name unusable and the base flatly wrong.
+			if not declaration.get_string(2).is_empty():
+				extends_name = declaration.get_string(2)
+		elif header.begins_with("extends "):
+			extends_name = header.substr(8).strip_edges()
+		elif header.begins_with("signal "):
+			# `at`, not `i`: a wrapped declaration starts where it starts, and `i` is now sitting on
+			# the line that closed it.
+			signals.append(_parse_signal(header, at + 1))
+		elif header.begins_with("const "):
+			constants.append(_parse_constant(header, at + 1))
+		elif header.begins_with("enum "):
+			enums.append(_parse_enum(header, at + 1))
+		elif header.begins_with("var "):
+			# The whole line here, not the header: which annotations a variable carries is the
+			# answer rather than noise in front of it, and `@export_range(0, 1)` is the hint.
+			variables.append(_parse_variable(stripped, at + 1))
+		elif header.begins_with("func ") or header.begins_with("static func "):
+			functions.append(_parse_function(header, at + 1, stripped))
+		elif header.begins_with("class "):
+			inner_classes.append(header.substr(6).split(":")[0].split(" ")[0].strip_edges())
 
 		if "preload(" in stripped or "load(" in stripped:
 			for dep: String in _extract_dependencies(stripped):
 				if dep not in dependencies:
 					dependencies.append(dep)
 
-	return {
+	# After the loop, because it needs the base the loop reads, and a file that declared one after
+	# its first function would otherwise be judged against the default.
+	_mark_virtuals(functions, extends_name)
+
+	var answer: Dictionary = {
 		"path": script_path,
 		"full_path": full_script_path,
 		"class_name": declared_class_name,
@@ -97,6 +139,98 @@ func get_gdscript_info(params: Dictionary) -> Dictionary:
 		"dependencies": dependencies,
 		"line_count": lines.size()
 	}
+	if Read.as_bool(params.get("include_inherited", false)):
+		_add_inherited(answer, [full_script_path])
+	return answer
+
+
+# Which of these functions the engine will call, asked of the engine.
+#
+# `is_virtual` was `name.begins_with("_")`, which is the convention for a private method and not
+# what the field says: it reported `_compute_damage` as something the engine calls, on every script
+# with a private helper in it. The virtuals are the ones the native ancestor declares with
+# `METHOD_FLAG_VIRTUAL`, which is a question `ClassDB` answers exactly, and `class_has_method` does
+# not: it says false for `_ready` on `Node`, so the method list is what has to be walked.
+func _mark_virtuals(functions: Array[Dictionary], extends_name: String) -> void:
+	var native: String = _native_ancestor(extends_name)
+	var virtuals: Dictionary = {}
+	if not native.is_empty():
+		for m: Dictionary in ClassDB.class_get_method_list(native, false):
+			var flags: int = Read.as_int(m.get("flags", 0))
+			if flags & METHOD_FLAG_VIRTUAL:
+				virtuals[str(m.get("name", ""))] = true
+	for one: Dictionary in functions:
+		one["is_virtual"] = virtuals.has(str(one.get("name", "")))
+
+
+# The native class at the top of this script's chain, or empty when the chain does not reach one.
+#
+# A base named by a script is followed; a base that is neither a script nor a class the engine knows
+# leaves nothing to ask, and then no function is called virtual rather than every underscore being
+# guessed at.
+func _native_ancestor(base: String) -> String:
+	var seen: Array[String] = []
+	var current: String = base
+	while true:
+		var path: String = _script_named(current)
+		if path.is_empty():
+			break
+		if path in seen:
+			return ""
+		seen.append(path)
+		var above: Dictionary = get_gdscript_info({"script_path": path})
+		if above.is_empty():
+			return ""
+		current = str(above.get("extends", ""))
+	return current if ClassDB.class_exists(current) else ""
+
+
+# The members this script's ancestors declare, appended to the lists they belong in.
+#
+# Only the script ancestors: `extends` naming a native class is ClassDB's question and
+# `editor_classes info` answers it with the whole hierarchy. A base is reachable either as a quoted
+# `res://` path or as a `class_name` in the project's class list, and a script whose base is neither
+# has no ancestor to read, which the answer says by leaving `inherits_from` short rather than by
+# refusing. Each entry carries `inherited_from`, so a caller can tell a member the script declares
+# from one it is given; a name a script overrides appears twice, at both lines, on purpose.
+func _add_inherited(answer: Dictionary, seen: Array[String]) -> void:
+	var inherits_from: Array[String] = []
+	var base: String = str(answer.get("extends", ""))
+	while true:
+		var base_path: String = _script_named(base)
+		if base_path.is_empty() or base_path in seen:
+			break
+		seen.append(base_path)
+		var above: Dictionary = get_gdscript_info({"script_path": base_path})
+		# A read that failed answers with an empty dictionary rather than with a flag, so that is
+		# what is asked. `_script_named` has already checked the file is there, which leaves only
+		# an open that fails, and the chain stops without recording a file nothing was read from.
+		if above.is_empty():
+			break
+		inherits_from.append(base_path)
+		for list_name: String in ["signals", "variables", "functions", "constants", "enums"]:
+			var mine: Array[Dictionary] = answer[list_name]
+			var theirs: Array[Dictionary] = above[list_name]
+			for member: Dictionary in theirs:
+				var carried: Dictionary = member.duplicate()
+				carried["inherited_from"] = base_path
+				mine.append(carried)
+		base = str(above.get("extends", ""))
+	answer["inherits_from"] = inherits_from
+
+
+# The file a base names, whether it named a path or a class, or empty for a native class.
+func _script_named(base: String) -> String:
+	if base.is_empty():
+		return ""
+	if base.begins_with('"') and base.ends_with('"'):
+		var quoted: String = base.substr(1, base.length() - 2)
+		return quoted if FileAccess.file_exists(quoted) else ""
+	for entry: Dictionary in ProjectSettings.get_global_class_list():
+		if str(entry.get("class", "")) == base:
+			var path: String = str(entry.get("path", ""))
+			return path if FileAccess.file_exists(path) else ""
+	return ""
 
 
 func _parse_signal(line: String, line_num: int) -> Dictionary:
@@ -105,13 +239,15 @@ func _parse_signal(line: String, line_num: int) -> Dictionary:
 	var params: Array[Dictionary] = []
 
 	if "(" in signal_text:
-		var parts: PackedStringArray = signal_text.split("(")
-		signal_name = parts[0].strip_edges()
-		if parts.size() > 1:
-			var params_text: String = parts[1].replace(")", "").strip_edges()
-			if not params_text.is_empty():
-				for p: String in params_text.split(","):
-					params.append(_parse_param(p.strip_edges()))
+		var paren_start: int = signal_text.find("(")
+		signal_name = signal_text.substr(0, paren_start).strip_edges()
+		# Through the same reader as a function's, because a signal's parameters are written the
+		# same way: `signal changed(d: Dictionary[String, int])` has one, and splitting on every
+		# comma answered with two.
+		var paren_end: int = _closing_paren(signal_text, paren_start)
+		if paren_end > paren_start:
+			for p: String in _arguments_in(signal_text.substr(paren_start + 1, paren_end - paren_start - 1)):
+				params.append(_parse_param(p))
 	else:
 		signal_name = signal_text
 
@@ -163,17 +299,20 @@ func _parse_enum(line: String, line_num: int) -> Dictionary:
 
 
 func _parse_variable(line: String, line_num: int) -> Dictionary:
-	var is_export: bool = line.begins_with("@export")
-	var is_onready: bool = "@onready" in line
+	var is_export: bool = false
+	var is_onready: bool = false
 	var export_hint: String = ""
 
-	if is_export:
-		var export_match: int = line.find("@export")
-		var hint_end: int = line.find("var ")
-		if hint_end > export_match:
-			var hint_part: String = line.substr(export_match + 7, hint_end - export_match - 7).strip_edges()
-			if hint_part.begins_with("_"):
-				export_hint = hint_part.substr(1).split(" ")[0]
+	# From the annotations themselves rather than from where they sit. `@onready @export var x` put
+	# the export second and so read as not exported, and a hint with a space in it was cut at it.
+	for one: String in Patterns.annotations_on(line):
+		if one.begins_with("export"):
+			is_export = true
+			var after: String = one.substr(6)
+			if after.begins_with("_"):
+				export_hint = after.substr(1)
+		elif one == "onready":
+			is_onready = true
 
 	var var_pos: int = line.find("var ")
 	if var_pos == -1:
@@ -213,7 +352,7 @@ func _parse_variable(line: String, line_num: int) -> Dictionary:
 	}
 
 
-func _parse_function(line: String, line_num: int) -> Dictionary:
+func _parse_function(line: String, line_num: int, annotated: String = "") -> Dictionary:
 	var is_static: bool = line.begins_with("static ")
 	var func_text: String = line
 
@@ -230,27 +369,166 @@ func _parse_function(line: String, line_num: int) -> Dictionary:
 		var paren_start: int = func_text.find("(")
 		name = func_text.substr(0, paren_start).strip_edges()
 
-		var paren_end: int = func_text.rfind(")")
+		var paren_end: int = _closing_paren(func_text, paren_start)
 		if paren_end > paren_start:
 			var params_text: String = func_text.substr(paren_start + 1, paren_end - paren_start - 1)
-			if not params_text.is_empty():
-				for p: String in params_text.split(","):
-					params.append(_parse_param(p.strip_edges()))
+			for p: String in _arguments_in(params_text):
+				params.append(_parse_param(p))
 
 		var after_paren: String = func_text.substr(paren_end + 1).strip_edges()
 		if after_paren.begins_with("->"):
-			return_type = after_paren.substr(2).replace(":", "").strip_edges()
+			# Cut at the colon that ends the signature rather than deleting every colon in the
+			# rest of the line: `func noted(a: int) -> void: print(a)` is one line, and the old
+			# reading answered with `void print(a)` as the return type.
+			return_type = _up_to(after_paren.substr(2), ":").strip_edges()
 
 	return {
 		"name": name,
 		"params": params,
 		"return_type": return_type,
-		"is_virtual": name.begins_with("_"),
+		# Filled in after the whole file is read, once the base is known; see `_mark_virtuals`.
+		"is_virtual": false,
 		"is_static": is_static,
+		# Said rather than left to be inferred: an abstract method has no body, so a caller that
+		# saw only the declaration would otherwise take it for one whose body it failed to read.
+		"is_abstract": "abstract" in Patterns.annotations_on(annotated),
 		"line": line_num
 	}
 
 
+# The commas that separate arguments are the ones outside every bracket and every string, and
+# `split(",")` could not tell them from the rest.
+#
+# `func place(at: Vector2 = Vector2(1, 2), name: String = "a,b")` has two parameters and was
+# answered with five, three of them invented and named after the pieces the split left behind:
+# `2)`, `b"`. Each real one also lost its default to the truncation, `Vector2(1`. A `Vector2` or
+# `Color` default is ordinary Godot, and a caller building a call from that signature writes
+# arguments that are not identifiers.
+func _arguments_in(text: String) -> Array[String]:
+	var pieces: Array[String] = []
+	var depth: int = 0
+	var quote: String = ""
+	var current: String = ""
+	for i: int in range(text.length()):
+		var ch: String = text[i]
+		if not quote.is_empty():
+			current += ch
+			if ch == quote and text[i - 1] != "\\":
+				quote = ""
+			continue
+		if ch == '"' or ch == "'":
+			quote = ch
+			current += ch
+			continue
+		if ch == "(" or ch == "[" or ch == "{":
+			depth += 1
+		elif ch == ")" or ch == "]" or ch == "}":
+			depth -= 1
+		elif ch == "," and depth == 0:
+			pieces.append(current.strip_edges())
+			current = ""
+			continue
+		current += ch
+	if not current.strip_edges().is_empty():
+		pieces.append(current.strip_edges())
+	return pieces
+
+
+# Whether this is a declaration whose brackets may carry on to the next line.
+func _can_wrap(header: String) -> bool:
+	for keyword: String in ["func ", "static func ", "enum ", "signal ", "var ", "const "]:
+		if header.begins_with(keyword):
+			return true
+	return false
+
+
+# How much this line opens that it does not close, ignoring brackets inside strings.
+func _bracket_depth(text: String) -> int:
+	var depth: int = 0
+	var quote: String = ""
+	for i: int in range(text.length()):
+		var ch: String = text[i]
+		if not quote.is_empty():
+			if ch == quote and text[i - 1] != "\\":
+				quote = ""
+			continue
+		if ch == '"' or ch == "'":
+			quote = ch
+		elif ch == "(" or ch == "[" or ch == "{":
+			depth += 1
+		elif ch == ")" or ch == "]" or ch == "}":
+			depth -= 1
+	return depth
+
+
+# The text up to the first [needle] outside every bracket and every string, or all of it.
+func _up_to(text: String, needle: String) -> String:
+	var depth: int = 0
+	var quote: String = ""
+	for i: int in range(text.length()):
+		var ch: String = text[i]
+		if not quote.is_empty():
+			if ch == quote and text[i - 1] != "\\":
+				quote = ""
+			continue
+		if ch == '"' or ch == "'":
+			quote = ch
+		elif ch == "(" or ch == "[" or ch == "{":
+			depth += 1
+		elif ch == ")" or ch == "]" or ch == "}":
+			depth -= 1
+		elif ch == needle and depth == 0:
+			return text.substr(0, i)
+	return text
+
+
+# The line with any trailing comment taken off, quote-aware so a `#` inside a string stays.
+#
+# The only one of these scanners that does not count brackets, on purpose: a `#` starts a comment
+# wherever it is, and there is no depth at which it does not. Giving this one the depth its
+# neighbours have puts the comment into the value of `var table := {  # keyed by name`, because the
+# 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.
+func _without_comment(line: String) -> String:
+	var quote: String = ""
+	for i: int in range(line.length()):
+		var ch: String = line[i]
+		if not quote.is_empty():
+			if ch == quote and line[i - 1] != "\\":
+				quote = ""
+			continue
+		if ch == "#":
+			return line.substr(0, i).strip_edges()
+		if ch == '"' or ch == "'":
+			quote = ch
+	return line.strip_edges()
+
+
+# Where the bracket opened at [from] closes, or -1 if it does not.
+#
+# `rfind(")")` took the last one on the line, which is the right answer until something after the
+# signature has a bracket in it: a trailing comment, or a string in a default value.
+func _closing_paren(text: String, from: int) -> int:
+	var depth: int = 0
+	var quote: String = ""
+	for i: int in range(from, text.length()):
+		var ch: String = text[i]
+		if not quote.is_empty():
+			if ch == quote and text[i - 1] != "\\":
+				quote = ""
+			continue
+		if ch == '"' or ch == "'":
+			quote = ch
+			continue
+		if ch == "(" or ch == "[" or ch == "{":
+			depth += 1
+		elif ch == ")" or ch == "]" or ch == "}":
+			depth -= 1
+			if depth == 0:
+				return i
+	return -1
+
+
 func _parse_param(param_text: String) -> Dictionary:
 	var name: String = ""
 	var type_hint: String = ""
@@ -274,7 +552,14 @@ func _parse_param(param_text: String) -> Dictionary:
 	else:
 		name = param_text
 
-	return {"name": name, "type": type_hint, "default": default_value}
+	# `...rest: Array` is a rest parameter, and the dots are the syntax rather than part of what it
+	# is called: answering `...rest` as the name gives a caller building a call site a name it
+	# cannot use. gdUnit4 alone declares 56 of these.
+	var is_rest: bool = name.begins_with("...")
+	if is_rest:
+		name = name.substr(3).strip_edges()
+
+	return {"name": name, "type": type_hint, "default": default_value, "is_rest": is_rest}
 
 
 func _extract_dependencies(line: String) -> Array[String]:

package/build/godot/operations/gdscript_authoring.gd

@@ -2,6 +2,7 @@ extends RefCounted
 
 const Read = preload("reading.gd")
 const Log = preload("logger.gd")
+const Patterns = preload("patterns.gd")
 
 var _log: Log
 
@@ -242,6 +243,10 @@ func _add_function(lines: Array[String], mod: Dictionary) -> int:
 		func_lines.append("\t" + bl)
 
 	var insert_line: int = _function_insertion_point(lines, position)
+	# A separator on the far side too when something follows, since `after_ready` and `after_init`
+	# put the new function immediately above an existing one and left the two declarations touching.
+	if insert_line < lines.size():
+		func_lines.append("")
 
 	for i: int in range(func_lines.size() - 1, -1, -1):
 		if lines.insert(insert_line, func_lines[i]) != OK:
@@ -256,7 +261,13 @@ func _variable_insertion_point(lines: Array[String]) -> int:
 	var before_func: int = lines.size()
 
 	for i: int in range(lines.size()):
-		var line: String = lines[i].strip_edges()
+		# Annotations off first. `@abstract class_name X` is one line in Godot 4.5 and later, and
+		# unstripped it matches nothing here, so the header is only found when some other line
+		# carries it. A script whose whole header is that one line leaves `after_header` at 0 and
+		# takes the new line above the `class_name`, where it does not parse; one that declares
+		# `extends` first takes it between the two, which does not parse either. Stripping also
+		# turns `@export var x` into `var x`, which is why the annotation names are gone below.
+		var line: String = Patterns.without_annotations(lines[i])
 		if line.begins_with("extends ") or line.begins_with("class_name "):
 			after_header = i + 1
 		elif line.begins_with("signal "):
@@ -266,8 +277,7 @@ func _variable_insertion_point(lines: Array[String]) -> int:
 			break
 
 	for i: int in range(after_header, before_func):
-		var line: String = lines[i].strip_edges()
-		if line.begins_with("var ") or line.begins_with("@export") or line.begins_with("@onready"):
+		if Patterns.without_annotations(lines[i]).begins_with("var "):
 			after_header = i + 1
 
 	return after_header
@@ -277,17 +287,14 @@ func _signal_insertion_point(lines: Array[String]) -> int:
 	var after_header: int = 0
 
 	for i: int in range(lines.size()):
-		var line: String = lines[i].strip_edges()
+		# As above: the annotations come off before the line is read, so an abstract class has a
+		# header to find and `@export var x` reads as the var it is.
+		var line: String = Patterns.without_annotations(lines[i])
 		if line.begins_with("extends ") or line.begins_with("class_name "):
 			after_header = i + 1
 		elif line.begins_with("signal "):
 			after_header = i + 1
-		elif (
-			line.begins_with("var ")
-			or line.begins_with("@export")
-			or line.begins_with("@onready")
-			or line.begins_with("func ")
-		):
+		elif line.begins_with("var ") or line.begins_with("func "):
 			break
 
 	return after_header
@@ -308,7 +315,11 @@ func _function_insertion_point(lines: Array[String], position: String) -> int:
 func _line_after_function(lines: Array[String], prefix: String) -> int:
 	var inside: bool = false
 	for i: int in range(lines.size()):
-		var line: String = lines[i].strip_edges()
+		# As above: an annotated `func` is still a `func`, and reading the raw line missed both
+		# ends of this. An annotated `_ready` was never found, so `after_ready` placed the new
+		# function at the end of the file, and an annotated function after `_ready` was not the
+		# boundary it is, so the new one went in after whichever later function was plain.
+		var line: String = Patterns.without_annotations(lines[i])
 		if line.begins_with(prefix):
 			inside = true
 		elif inside and (line.begins_with("func ") or line.begins_with("static func ")):