gdharness 1.2.36 → 1.2.37

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

@@ -4,6 +4,7 @@ extends Node
 ## Resource files, shaders, tilesets and themes, written through the open editor.
 
 const FileReads = preload("../file_reads.gd")
+const HeadlessCheck = preload("../headless_check.gd")
 const PropertyValues = preload("../property_values.gd")
 const Read = preload("../reading.gd")
 const SceneFile = preload("../scene_file.gd")
@@ -118,9 +119,12 @@ func _load_theme(theme_path: String) -> Theme:
 ## Read back because a property can be set and still not be saved: one without storage, a
 ## script variable that is not exported. Both were answered as changed.
 func _save_checked(resource: Resource, path: String, names: Array, previous: Variant) -> String:
-	var saving: Error = ResourceSaver.save(resource, path)
+	var saving: Error = SceneFile.save_keeping_uid(resource, path)
 	if saving != OK:
 		return "Failed to save %s: %s" % [path, error_string(saving)]
+	var unkept: String = _unkept_headless(resource, path, names, previous)
+	if not unkept.is_empty():
+		return "Nothing was written: " + unkept + HeadlessCheck.put_back(path, previous)
 	var loaded: Resource = ResourceLoader.load(path, "", ResourceLoader.CACHE_MODE_IGNORE)
 	var lost: String = ""
 	if loaded == null:
@@ -141,14 +145,50 @@ func _save_checked(resource: Resource, path: String, names: Array, previous: Var
 	if lost.is_empty():
 		_written(path)
 		return ""
+	return lost + HeadlessCheck.put_back(path, previous)
+
+
+## Outside the editor, puts back in the file just saved at [param path] what a script that is not a
+## tool changed and the call did not ask for, [param names] being what it asked for, and answers ""
+## or why that did not hold. See [HeadlessCheck].
+func _unkept_headless(resource: Resource, path: String, names: Array, previous: Variant) -> String:
+	if Engine.is_editor_hint():
+		return ""
+	var script: Script = resource.get_script()
+	var scripted: bool = script != null and not script.is_tool()
+	if not path.ends_with(".tres"):
+		if scripted or HeadlessCheck.holds_scripted_embedded(resource, {}):
+			return (
+				(
+					(
+						"%s is a binary resource with a script that is not a tool, and what that script "
+						+ "changed when a headless engine loaded it cannot be told apart from the file here. "
+					)
+					% path
+				)
+				+ HeadlessCheck.REMEDY
+			)
+		return ""
+	var before: String = ""
 	if previous is PackedByteArray:
 		var bytes: PackedByteArray = previous
-		var file: FileAccess = FileAccess.open(path, FileAccess.WRITE)
-		if file == null or not file.store_buffer(bytes):
-			return lost + " Putting the file back as it was failed too."
-	elif DirAccess.remove_absolute(ProjectSettings.globalize_path(path)) != OK:
-		return lost + " Removing the file it wrote failed too."
-	return lost
+		before = bytes.get_string_from_utf8()
+	var asked: Dictionary = {"script": true}
+	var reached: Dictionary = {}
+	for key: Variant in names:
+		var property: String = str(key)
+		asked[property] = true
+		asked[property.get_slice(":", 0)] = true
+		reached.merge(HeadlessCheck.reached(resource, property))
+	return HeadlessCheck.settle_saved(
+		path,
+		before,
+		HeadlessCheck.stored(resource).values(),
+		resource if scripted else null,
+		asked,
+		reached,
+		func() -> Error: return SceneFile.save_keeping_uid(resource, path)
+	)
 
 
 func create_resource(args: Dictionary) -> Dictionary:
@@ -321,7 +361,7 @@ func create_tileset(args: Dictionary) -> Dictionary:
 	var folder: String = SceneFile.make_folder_for(tileset_path)
 	if not folder.is_empty():
 		return {"ok": false, "error": folder}
-	var saving: Error = ResourceSaver.save(tileset, tileset_path)
+	var saving: Error = SceneFile.save_keeping_uid(tileset, tileset_path)
 	if saving != OK:
 		return {"ok": false, "error": "Failed to save %s: %s" % [tileset_path, error_string(saving)]}
 
@@ -443,6 +483,7 @@ func set_tilemap_cells(args: Dictionary) -> Dictionary:
 	# reports placing tiles and a scene that shows none.
 	var tile_set: TileSet = layered.tile_set if layered != null else single.tile_set
 
+	scene.asked(node, ["layer_%d/tile_data" % layer if layered != null else "tile_map_data"])
 	var wanted: Array = []
 	for index: int in placed.size():
 		var cell: Array = _cell(placed[index], index, tile_set)
@@ -621,6 +662,19 @@ func _cell_at(node: Node, layer: int, at: Vector2i) -> Array:
 	return []
 
 
+## Saves [param theme] over [param theme_path] with [param item] changed, answering "" or why not.
+func _save_theme(theme: Theme, theme_path: String, item: String) -> String:
+	var previous: PackedByteArray = FileAccess.get_file_as_bytes(theme_path)
+	var saving: Error = SceneFile.save_keeping_uid(theme, theme_path)
+	if saving != OK:
+		return "Failed to save %s: %s" % [theme_path, error_string(saving)]
+	var unkept: String = _unkept_headless(theme, theme_path, [item], previous)
+	if not unkept.is_empty():
+		return "Nothing was written: " + unkept + HeadlessCheck.put_back(theme_path, previous)
+	_written(theme_path)
+	return ""
+
+
 func set_theme_color(args: Dictionary) -> Dictionary:
 	var theme_path: String = _ensure_res_path(str(args.get("themePath", "")))
 	if theme_path == "res://":
@@ -644,11 +698,9 @@ func set_theme_color(args: Dictionary) -> Dictionary:
 	)
 	theme.set_color(color_name, control_type, color)
 
-	var save_result: Error = ResourceSaver.save(theme, theme_path)
-	if save_result != OK:
-		return {"ok": false, "error": "Failed to save %s: %s" % [theme_path, error_string(save_result)]}
-
-	_written(theme_path)
+	var unsaved: String = _save_theme(theme, theme_path, "%s/colors/%s" % [control_type, color_name])
+	if not unsaved.is_empty():
+		return {"ok": false, "error": unsaved}
 
 	var saved: Theme = _load_theme(theme_path)
 	if saved == null or not saved.has_color(color_name, control_type):
@@ -680,11 +732,9 @@ func set_theme_font_size(args: Dictionary) -> Dictionary:
 
 	theme.set_font_size(font_size_name, control_type, Read.as_int(args.get("size", 0)))
 
-	var save_result: Error = ResourceSaver.save(theme, theme_path)
-	if save_result != OK:
-		return {"ok": false, "error": "Failed to save %s: %s" % [theme_path, error_string(save_result)]}
-
-	_written(theme_path)
+	var unsaved: String = _save_theme(theme, theme_path, "%s/font_sizes/%s" % [control_type, font_size_name])
+	if not unsaved.is_empty():
+		return {"ok": false, "error": unsaved}
 
 	var saved: Theme = _load_theme(theme_path)
 	if saved == null or not saved.has_font_size(font_size_name, control_type):

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

@@ -90,7 +90,7 @@ func _missing_on(node: Node, missing: String) -> String:
 	if probe.reload() == OK:
 		return missing
 	return (
-		"%s. Its script, %s, does not compile, so the editor knows none of what it declares."
+		"%s. Its script, %s, does not compile, so none of what it declares is known here."
 		% [missing, script.resource_path]
 	)
 
@@ -213,6 +213,10 @@ func create_scene(args: Dictionary) -> Dictionary:
 
 	var root: Node = ClassDB.instantiate(root_node_type)
 	root.name = root_node_name
+	var scene: SceneFile = SceneFile.new()
+	scene.root = root
+	scene.path = scene_path
+	scene.asked(root, ["script"])
 
 	if not script_path.is_empty():
 		var full_script_path: String = _to_scene_res_path(project_path, script_path)
@@ -238,9 +242,6 @@ func create_scene(args: Dictionary) -> Dictionary:
 	if not folder.is_empty():
 		root.free()
 		return {"ok": false, "error": folder}
-	var scene: SceneFile = SceneFile.new()
-	scene.root = root
-	scene.path = scene_path
 	var written: Dictionary = scene.write()
 	if not written.is_empty():
 		return written
@@ -307,6 +308,10 @@ func add_node(args: Dictionary) -> Dictionary:
 	parent.add_child(new_node)
 	Placing.place(new_node, place)
 	Placing.own(new_node, root)
+	var unsettled: String = scene.settle()
+	if not unsettled.is_empty():
+		return scene.refuse("Nothing was written: " + unsettled)
+	scene.asked(new_node, properties.keys())
 	var refused_property: String = _properties.write_all(new_node, properties)
 	if not refused_property.is_empty():
 		return scene.refuse(refused_property)
@@ -415,6 +420,7 @@ func duplicate_node(args: Dictionary) -> Dictionary:
 	target_parent.add_child(duplicated_node)
 	Placing.own(duplicated_node, root)
 	Placing.reconnect(copies, source)
+	scene.copied(copies)
 
 	var new_path: String = scene.path_of(duplicated_node)
 	var written: Dictionary = scene.write(
@@ -530,6 +536,7 @@ func set_node_properties(args: Dictionary) -> Dictionary:
 		if not unusable.is_empty():
 			return scene.refuse(unusable)
 
+	scene.asked(node, properties.keys())
 	var refused_property: String = _properties.write_all(node, properties)
 	if not refused_property.is_empty():
 		return scene.refuse(_missing_on(node, refused_property))
@@ -570,12 +577,10 @@ func get_node_properties(args: Dictionary) -> Dictionary:
 	var props: Dictionary = _properties_of(node, include_defaults, scene.set_here(node))
 	var cells: Dictionary = ResourceTools.cells_of(node)
 	scene.close()
-	var answer: Dictionary = {
-		"ok": true,
-		"nodePath": node_path,
-		"properties": props,
-		"unsavedInEditor": SceneFile.unsaved(scene_path)
-	}
+	var answer: Dictionary = {"ok": true, "nodePath": node_path, "properties": props}
+	# Only an editor holds anything unsaved; a headless engine answering false would say it looked.
+	if Engine.is_editor_hint():
+		answer["unsavedInEditor"] = SceneFile.unsaved(scene_path)
 	answer.merge(cells)
 	# An empty answer read as a node with nothing on it, rather than one with nothing changed.
 	if props.is_empty() and not include_defaults:
@@ -600,7 +605,10 @@ func save_scene(args: Dictionary) -> Dictionary:
 			return {"ok": false, "error": unsaved}
 
 	var open_root: Node = null
-	for open: Node in EditorInterface.get_open_scene_roots():
+	var open_roots: Array[Node] = []
+	if Engine.is_editor_hint():
+		open_roots = EditorInterface.get_open_scene_roots()
+	for open: Node in open_roots:
 		if open.scene_file_path == scene_path:
 			open_root = open
 	if open_root != null and target_path == scene_path:
@@ -618,7 +626,7 @@ func save_scene(args: Dictionary) -> Dictionary:
 		written = SceneFile.save_packed(packed, target_path)
 	else:
 		var scene: SceneFile = SceneFile.new()
-		var refused: Dictionary = scene.open(scene_path, false)
+		var refused: Dictionary = scene.open(scene_path, true)
 		if not refused.is_empty():
 			return refused
 		scene.path = target_path
@@ -897,4 +905,7 @@ func list_connections(args: Dictionary) -> Dictionary:
 				)
 
 	scene.close()
-	return {"ok": true, "connections": connections, "unsavedInEditor": SceneFile.unsaved(scene_path)}
+	var listed: Dictionary = {"ok": true, "connections": connections}
+	if Engine.is_editor_hint():
+		listed["unsavedInEditor"] = SceneFile.unsaved(scene_path)
+	return listed

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

@@ -168,6 +168,12 @@ func _argument_for(
 				% [called, named, type_string(wants), index + 1, JSON.stringify(sent)]
 			)
 		}
+	var rounded: String = Values.inexact(sent, wants)
+	if not rounded.is_empty():
+		return {
+			"type": "error",
+			"message": "%s.%s takes int as argument %d: %s." % [called, named, index + 1, rounded]
+		}
 	var given: Variant = _values.fitted(sent, wants)
 	if not Values.acceptable(given, wants):
 		return {
@@ -242,6 +248,9 @@ func _value_for(
 				"message": "%s.%s holds an object: %s" % [called, named, named_object["message"]]
 			}
 		return {"value": named_object["object"]}
+	var rounded: String = Values.inexact(value, wanted)
+	if not rounded.is_empty():
+		return {"type": "error", "message": "%s.%s holds int: %s." % [called, named, rounded]}
 	var as_sent: Variant = _values.fitted(value, TYPE_NIL)
 	var cut: bool = Values.cuts(value, wanted)
 	var given: Variant = as_sent

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

@@ -156,6 +156,11 @@ static func cuts(given: Variant, type: int) -> bool:
 	return not (whole and (value == 0.0 or value == 1.0))
 
 
+## Why [param given] may not be the whole number sent, or "": see [method Serialisation.inexact].
+static func inexact(given: Variant, type: int) -> String:
+	return Serialisation.inexact(given, type)
+
+
 ## How a value of [param type] is written to be read as one, or empty when it is not built from fields.
 static func written_as(type: int) -> String:
 	return Serialisation.written_as(type)

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

@@ -255,6 +255,9 @@ func wait_until(params: Dictionary) -> Dictionary:
 	var refused: String = _not_comparable(current, wanted, node_path, property)
 	if refused.is_empty():
 		refused = _cut_to_fit(params["value"], typeof(current), node_path, property)
+	var rounded: String = Values.inexact(params["value"], typeof(current))
+	if refused.is_empty() and not rounded.is_empty():
+		refused = "%s.%s holds int: %s." % [node_path, property, rounded]
 	var never_held: bool = typeof(wanted) != TYPE_NIL and typeof(wanted) != TYPE_OBJECT
 	if refused.is_empty() and declared == TYPE_OBJECT and never_held:
 		refused = (

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

@@ -16,6 +16,10 @@ const Read = preload("reading.gd")
 const NUMBERS: Array[int] = [TYPE_BOOL, TYPE_INT, TYPE_FLOAT]
 const TEXTS: Array[int] = [TYPE_STRING, TYPE_STRING_NAME, TYPE_NODE_PATH]
 
+# 2^53. A JSON number is a double, and every whole number below this one in size has a double of
+# its own; from here on two or more share each double, so one arriving tells nobody which was sent.
+const EXACT: int = 9007199254740992
+
 # The types that cross as a plain JSON list and have to be built back into themselves. A list is
 # what a caller can write by hand and what the serialiser answers with, and the parameter or
 # property being written is the only thing that knows which of these it wanted.
@@ -53,6 +57,8 @@ const LIST_TYPES: Array[int] = [
 # type it wanted.
 const SERIALISERS: Dictionary = {
 	TYPE_NIL: "_serialize_nil",
+	TYPE_INT: "_serialize_int",
+	TYPE_PACKED_INT64_ARRAY: "_serialize_ints",
 	TYPE_FLOAT: "_serialize_float",
 	TYPE_PACKED_FLOAT32_ARRAY: "_serialize_floats",
 	TYPE_PACKED_FLOAT64_ARRAY: "_serialize_floats",
@@ -109,6 +115,8 @@ const BUILDERS: Dictionary = {
 	"NodePath": "_build_node_path",
 	"PackedByteArray": "_build_bytes",
 	"float": "_build_float",
+	"int": "_build_int",
+	"RID": "_build_rid",
 	"Dictionary": "_build_dictionary",
 }
 
@@ -136,6 +144,8 @@ const REQUIRED: Dictionary = {
 	"NodePath": [["path"]],
 	"PackedByteArray": [["base64"]],
 	"float": [["value"]],
+	"int": [["value"]],
+	"RID": [["id"]],
 	"Dictionary": [["entries"]],
 }
 
@@ -243,9 +253,40 @@ func deserialize_value(value: Variant) -> Variant:
 		return fields
 	if tag == "Dictionary" and not pairs(fields["entries"]):
 		return fields
+	# Digits only: the tag is there to carry what a number cannot, and {"value": 5} meant for some
+	# other shape is not to be read as 5.
+	if tag == "int" and not (fields["value"] is String and _exact_int(fields["value"]) != null):
+		return fields
+	if tag == "RID" and _exact_int(fields["id"]) == null:
+		return fields
 	return call(builder, fields)
 
 
+## [param held] as the whole number it spells exactly, or null: an int, a JSON number that is whole
+## and no larger than a double holds exactly, the digits of one, or the int tag carrying them. A
+## fraction, or a number past 2^53 that arrived as a number and so may already be a neighbour of the
+## one meant, is no id.
+func _exact_int(held: Variant) -> Variant:
+	if held is int:
+		return held
+	if held is float:
+		var number: float = held
+		if is_finite(number) and number == floorf(number) and absf(number) < EXACT:
+			return int(number)
+		return null
+	if held is String:
+		var digits: String = held
+		var parsed: int = digits.to_int()
+		if digits.is_valid_int() and str(parsed) == digits:
+			return parsed
+		return null
+	if held is Dictionary:
+		var tagged: Dictionary = held
+		if str(tagged.get("_type", "")) == "int" and tagged.has("value"):
+			return _exact_int(tagged["value"])
+	return null
+
+
 ## The components a path reads off [param value], by the names GDScript gives them, or none for a
 ## value that has none: a vector's axes, a colour's channels, a rectangle's corners and size, a
 ## transform's basis and origin. A value of one of these is a copy wherever it is read, so a write
@@ -393,6 +434,11 @@ func fitted(value: Variant, type: int) -> Variant:
 	if not simple.has(type) or not simple.has(typeof(rebuilt)):
 		return rebuilt
 
+	# Digits are read as digits, since read as JSON they become a double and one past 2^53 a
+	# neighbour of the number written.
+	if rebuilt is String and type == TYPE_INT and _exact_int(rebuilt) != null:
+		return _exact_int(rebuilt)
+
 	if rebuilt is String and type != TYPE_STRING:
 		var text: String = rebuilt
 		var parsed: Variant = Read.json_or_null(text)
@@ -408,13 +454,33 @@ func fitted(value: Variant, type: int) -> Variant:
 	return type_convert(rebuilt, type)
 
 
+## Why [param given], meant for an int, may not be the number that was sent, or "" when it is. A
+## JSON number is a double wherever it is read, so a whole number from 2^53 on arrives as the nearest
+## double to the one written: 9007199254740993 sent as a number arrives as 9007199254740992, and a
+## seed written that way would be stored as its neighbour with the answer saying it was written.
+static func inexact(given: Variant, type: int) -> String:
+	if type != TYPE_INT or (typeof(given) != TYPE_FLOAT and typeof(given) != TYPE_INT):
+		return ""
+	var number: float = Read.as_float(given)
+	if not is_finite(number) or absf(number) < EXACT:
+		return ""
+	return (
+		(
+			"%s is 2^53 or more, where a JSON number holds a whole number only to the nearest double,"
+			+ ' so it may not be the number sent: send the digits as {"_type": "int", "value": "..."}'
+			+ ", the form a read answers with"
+		)
+		% String.num(number, 0)
+	)
+
+
 ## How a value of [param type] is written to be read as one, for a refusal to name, or empty for a
 ## type that is not built from fields. A refusal naming only the two types left a caller to find
 ## the shape in the description of another op.
 static func written_as(type: int) -> String:
 	var tag: String = type_string(type)
 	var alternatives: Array = REQUIRED.get(tag, [])
-	if alternatives.is_empty() or tag == "float" or tag == "Dictionary":
+	if alternatives.is_empty() or tag in ["float", "int", "Dictionary"]:
 		return ""
 	var keys: Array = alternatives[0]
 	var parts: Array[String] = []
@@ -530,10 +596,32 @@ func _serialize_node_path(value: NodePath) -> Dictionary:
 	return {"path": str(value), "_type": "NodePath"}
 
 
-# An id rather than nothing, because two properties holding the same RID are worth telling apart
-# even though neither can be handed back to the engine.
+# By its id, which is all an RID is from outside the server holding it, and which builds it back:
+# a viewport's RID read off one call is what RenderingServer's render timing takes in the next.
 func _serialize_rid(value: RID) -> Dictionary:
-	return {"id": value.get_id(), "_type": "RID"}
+	return {"id": _serialize_int(value.get_id()), "_type": "RID"}
+
+
+# A whole number from 2^53 on as its digits, because JSON numbers are doubles on the server's side
+# and on the engine's, and from there on neighbouring whole numbers share a double. A RefCounted's
+# instance id is one, with its top bit set, and a resource uid another; read as numbers they came
+# back as a neighbouring id, which named nothing or something else.
+func _serialize_int(value: int) -> Variant:
+	if value > -EXACT and value < EXACT:
+		return value
+	return {"_type": "int", "value": str(value)}
+
+
+# A packed list of 64-bit numbers stays the JSON list it is unless something in it is too large for
+# a double to hold.
+func _serialize_ints(value: PackedInt64Array) -> Variant:
+	for number: int in value:
+		if number <= -EXACT or number >= EXACT:
+			var items: Array = []
+			for each: int in value:
+				items.append(_serialize_int(each))
+			return items
+	return value
 
 
 # A bound method, said in the terms a caller could act on: what it is on, and what it is called.
@@ -672,7 +760,7 @@ func _describe_object(value: Object) -> Dictionary:
 	# in a costume and reads as if the object had been asked and had nothing to say.
 	if value.has_method("_to_string"):
 		described["says"] = value.to_string()
-	described["id"] = value.get_instance_id()
+	described["id"] = _serialize_int(value.get_instance_id())
 	return described
 
 
@@ -808,6 +896,16 @@ func _build_float(fields: Dictionary) -> float:
 	return Read.as_float(fields)
 
 
+func _build_int(fields: Dictionary) -> int:
+	var exact: int = _exact_int(fields["value"])
+	return exact
+
+
+func _build_rid(fields: Dictionary) -> RID:
+	var id: int = _exact_int(fields["id"])
+	return rid_from_int64(id)
+
+
 ## The entries of a dictionary whose keys are not all text. JSON carries every number as a float,
 ## and a dictionary keys 1.0 apart from 1, so a whole-number key is built as an int: the key a
 ## game uses far more often, and one JSON cannot tell from the float.

package/build/godot/operations/editor_tools.gd

@@ -0,0 +1,57 @@
+extends RefCounted
+
+## The editor addon's scene and resource tools, run by a headless engine for a project no editor
+## serves.
+##
+## They are the editor's own scripts, loaded from beside these operations in the package, so a write
+## made here passes the same checks and answers in the same shape. What the engine does that an
+## editor does not, running every script, is put back in scene_file.gd and headless_check.gd.
+
+const ResourceTools = preload("../addons/gdharness_editor/tools/resource_tools.gd")
+const SceneTools = preload("../addons/gdharness_editor/tools/scene_tools.gd")
+
+const SCENE_COMMANDS: Array[String] = [
+	"create_scene",
+	"save_scene",
+	"add_node",
+	"get_node_properties",
+	"set_node_properties",
+	"duplicate_node",
+	"reparent_node",
+	"delete_node",
+	"connect_signal",
+	"disconnect_signal",
+	"list_connections",
+]
+const RESOURCE_COMMANDS: Array[String] = [
+	"set_tilemap_cells",
+	"create_resource",
+	"modify_resource",
+	"create_shader",
+	"create_tileset",
+	"set_theme_color",
+	"set_theme_font_size",
+]
+
+
+## Runs the tool [code]command[/code] names with [code]arguments[/code], answering what it answers.
+static func run(params: Dictionary) -> Dictionary:
+	var command: String = str(params.get("command", ""))
+	var given: Variant = params.get("arguments", {})
+	if not given is Dictionary:
+		return {"ok": false, "error": "arguments must be an object."}
+	var arguments: Dictionary = given
+	var tools: Node = null
+	if command in SCENE_COMMANDS:
+		tools = SceneTools.new()
+	elif command in RESOURCE_COMMANDS:
+		tools = ResourceTools.new()
+	else:
+		return {"ok": false, "error": "No editor tool runs headless as " + command}
+	var answer: Variant = tools.call(command, arguments)
+	tools.free()
+	if answer is Dictionary:
+		return answer
+	return {
+		"ok": false, "error": "%s answered %s rather than an object." % [command, type_string(typeof(answer))]
+	}

package/build/godot/operations/gdscript_analysis.gd

@@ -154,6 +154,21 @@ func get_gdscript_info(params: Dictionary) -> Dictionary:
 		if not declaring in dependencies:
 			dependencies.append(declaring)
 
+	# An autoload is named the way a class is, and its script is one this one needs to compile, but
+	# the project loads it rather than this script, so it is answered apart from dependencies.
+	var global_autoloads: Dictionary = {}
+	for property: Dictionary in ProjectSettings.get_property_list():
+		var setting: String = str(property.get("name", ""))
+		var value: String = (
+			str(ProjectSettings.get_setting(setting)) if setting.begins_with("autoload/") else ""
+		)
+		if value.begins_with("*"):
+			global_autoloads[setting.trim_prefix("autoload/")] = value.trim_prefix("*")
+	var autoloads_used: Array[Dictionary] = []
+	for used: String in Dependencies.classes_used_in(content, global_autoloads):
+		if str(global_autoloads[used]) != full_script_path:
+			autoloads_used.append({"name": used, "path": str(global_autoloads[used])})
+
 	var answer: Dictionary = {
 		"path": script_path,
 		"full_path": full_script_path,
@@ -167,6 +182,7 @@ func get_gdscript_info(params: Dictionary) -> Dictionary:
 		"inner_classes": inner_classes,
 		"dependencies": dependencies,
 		"classes_used": classes_used,
+		"autoloads_used": autoloads_used,
 		"line_count": lines.size()
 	}
 	if Read.as_bool(params.get("include_inherited", false)):
@@ -386,10 +402,15 @@ func _parse_variable(line: String, line_num: int) -> Dictionary:
 	else:
 		name = var_text.split(" ")[0].strip_edges()
 
+	# Null for a declaration with no value, which as an empty string read as `= ""`.
+	var stated_default: Variant = null
+	if "=" in var_text:
+		stated_default = default_value
+
 	return {
 		"name": name,
 		"type": type_hint,
-		"default_value": default_value,
+		"default_value": stated_default,
 		"is_export": is_export,
 		"export_hint": export_hint,
 		"is_onready": is_onready,
@@ -582,7 +603,10 @@ func _parse_param(param_text: String) -> Dictionary:
 	if is_rest:
 		name = name.substr(3).strip_edges()
 
-	return {"name": name, "type": type_hint, "default": default_value, "is_rest": is_rest}
+	var stated_default: Variant = null
+	if "=" in param_text:
+		stated_default = default_value
+	return {"name": name, "type": type_hint, "default": stated_default, "is_rest": is_rest}
 
 
 func _collect_dependencies(line: String, into: Array[String]) -> void:

package/build/godot/operations/gdscript_authoring.gd

@@ -396,8 +396,11 @@ func _add_function(lines: Array[String], mod: Dictionary, placed: Array[Dictiona
 	var declared_at: int = insert_line + func_lines.size()
 	func_lines.append("func " + func_name + "(" + func_params + ") -> " + return_type + ":")
 
-	for bl: String in body.split("\n"):
-		func_lines.append("\t" + bl)
+	# The body's statements relative to the function, whether or not the caller indented them for
+	# it: a body written with its tab already on came out two levels in. A blank line stays empty,
+	# since an indent alone on it is trailing whitespace to every formatter.
+	for bl: String in body.dedent().split("\n"):
+		func_lines.append("" if bl.strip_edges().is_empty() else "\t" + bl)
 
 	var below: int = _blank_run(lines, insert_line, 1)
 	if insert_line + below < lines.size():