gdharness 1.2.23 → 1.2.25

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

@@ -321,11 +321,25 @@ static func acceptable(value: Variant, type: int) -> bool:
 ## The conversion is also what restores a packed array's exact type. Those cross as the plain JSON
 ## lists they fit into, so what comes back from the wire is an Array, and the parameter is what says
 ## it was a PackedStringArray.
+##
+## A dictionary with no tag is read as the type wanted when it carries that type's fields, as
+## scene_node and resource_edit read one: runtime_invoke refused {"x": 140, "y": 300} for a Vector2
+## argument the editor tools took, so one value was right for one tool and wrong for the next. The
+## value as sent is what is tagged, since the builders read a nested vector from its own fields.
 func fitted(value: Variant, type: int) -> Variant:
 	var rebuilt: Variant = deserialize_value(value)
 	if type == TYPE_NIL or typeof(rebuilt) == type:
 		return rebuilt
 
+	if value is Dictionary and type != TYPE_DICTIONARY:
+		var fields: Dictionary = value
+		if not fields.has("_type"):
+			var tagged: Dictionary = fields.duplicate()
+			tagged["_type"] = type_string(type)
+			var built: Variant = deserialize_value(tagged)
+			if typeof(built) == type:
+				return built
+
 	if rebuilt is Array and LIST_TYPES.has(type):
 		return type_convert(rebuilt, type)
 
@@ -348,6 +362,21 @@ func fitted(value: Variant, type: int) -> Variant:
 	return type_convert(rebuilt, type)
 
 
+## 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":
+		return ""
+	var keys: Array = alternatives[0]
+	var parts: Array[String] = []
+	for key: Variant in keys:
+		parts.append('"%s": ...' % key)
+	return "{%s}" % ", ".join(parts)
+
+
 ## Whether [param fields] carries every key of any one of [param alternatives].
 ##
 ## More than one spelling because a rectangle has two: the two corners it is answered with, and the

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

@@ -101,8 +101,14 @@ func set_property(params: Dictionary) -> Dictionary:
 					"type": "error",
 					"message":
 					(
-						"%s.%s holds %s and the value given is %s, which cannot become one."
-						% [reached["called"], named, type_string(wanted), type_string(typeof(given))]
+						"%s.%s holds %s and the value given is %s, which cannot become one.%s"
+						% [
+							reached["called"],
+							named,
+							type_string(wanted),
+							type_string(typeof(given)),
+							_written_as(wanted)
+						]
 					)
 				}
 		var typed: Dictionary = _values.typed_like(given, old_value, _element_object.bind(node, node_path))
@@ -301,8 +307,15 @@ func call_method(params: Dictionary) -> Dictionary:
 				"type": "error",
 				"message":
 				(
-					"%s.%s takes %s as argument %d and was given %s, which cannot be converted."
-					% [reached["called"], named, type_string(wants), index + 1, type_string(typeof(given))]
+					"%s.%s takes %s as argument %d and was given %s, which cannot be converted.%s"
+					% [
+						reached["called"],
+						named,
+						type_string(wants),
+						index + 1,
+						type_string(typeof(given)),
+						_written_as(wants)
+					]
 				)
 			}
 		# A typed list or map is built as one, since a plain one handed to such a parameter raises
@@ -492,6 +505,13 @@ func _element_object(
 
 
 ## "list" or "map", for a refusal about a typed container.
+## The sentence a refusal ends with for a type built from fields, naming the shape that is read as
+## one, or nothing for a type that is not.
+static func _written_as(type: int) -> String:
+	var shape: String = Values.written_as(type)
+	return "" if shape.is_empty() else " A %s is sent as %s." % [type_string(type), shape]
+
+
 static func _sort_of(container: Variant) -> String:
 	return "list" if container is Array else "map"
 

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

@@ -65,6 +65,11 @@ static func acceptable(value: Variant, type: int) -> bool:
 	return Serialisation.acceptable(value, 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)
+
+
 ## The declared type of one parameter of a method, or TYPE_NIL when the method or the parameter
 ## is not there, which reads as "no opinion".
 func parameter_type(object: Object, method: String, index: int) -> int:

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

@@ -321,11 +321,25 @@ static func acceptable(value: Variant, type: int) -> bool:
 ## The conversion is also what restores a packed array's exact type. Those cross as the plain JSON
 ## lists they fit into, so what comes back from the wire is an Array, and the parameter is what says
 ## it was a PackedStringArray.
+##
+## A dictionary with no tag is read as the type wanted when it carries that type's fields, as
+## scene_node and resource_edit read one: runtime_invoke refused {"x": 140, "y": 300} for a Vector2
+## argument the editor tools took, so one value was right for one tool and wrong for the next. The
+## value as sent is what is tagged, since the builders read a nested vector from its own fields.
 func fitted(value: Variant, type: int) -> Variant:
 	var rebuilt: Variant = deserialize_value(value)
 	if type == TYPE_NIL or typeof(rebuilt) == type:
 		return rebuilt
 
+	if value is Dictionary and type != TYPE_DICTIONARY:
+		var fields: Dictionary = value
+		if not fields.has("_type"):
+			var tagged: Dictionary = fields.duplicate()
+			tagged["_type"] = type_string(type)
+			var built: Variant = deserialize_value(tagged)
+			if typeof(built) == type:
+				return built
+
 	if rebuilt is Array and LIST_TYPES.has(type):
 		return type_convert(rebuilt, type)
 
@@ -348,6 +362,21 @@ func fitted(value: Variant, type: int) -> Variant:
 	return type_convert(rebuilt, type)
 
 
+## 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":
+		return ""
+	var keys: Array = alternatives[0]
+	var parts: Array[String] = []
+	for key: Variant in keys:
+		parts.append('"%s": ...' % key)
+	return "{%s}" % ", ".join(parts)
+
+
 ## Whether [param fields] carries every key of any one of [param alternatives].
 ##
 ## More than one spelling because a rectangle has two: the two corners it is answered with, and the

package/build/godot/operations/godot_operations.gd

@@ -29,6 +29,10 @@ const ProjectDiagnostics = preload("project_diagnostics.gd")
 const RenameChecks = preload("rename_checks.gd")
 const ResourceFiles = preload("resource_files.gd")
 
+## Printed once the answer is written, after which the engine runs the project's autoloads. Kept in
+## step with `ANSWERED` in src/headless.ts.
+const ANSWERED: String = "[gdharness] answered"
+
 var _log: Log
 
 
@@ -86,6 +90,9 @@ func _init() -> void:
 		_log.error("Could not write the answer to " + answer_path)
 		quit(1)
 		return
+	# On stderr, where the engine's errors go, so the server can tell what the project's autoloads
+	# report after this from what the operation reported before it.
+	printerr(ANSWERED)
 	quit()
 
 

package/build/godot/operations/serialisation.gd

@@ -321,11 +321,25 @@ static func acceptable(value: Variant, type: int) -> bool:
 ## The conversion is also what restores a packed array's exact type. Those cross as the plain JSON
 ## lists they fit into, so what comes back from the wire is an Array, and the parameter is what says
 ## it was a PackedStringArray.
+##
+## A dictionary with no tag is read as the type wanted when it carries that type's fields, as
+## scene_node and resource_edit read one: runtime_invoke refused {"x": 140, "y": 300} for a Vector2
+## argument the editor tools took, so one value was right for one tool and wrong for the next. The
+## value as sent is what is tagged, since the builders read a nested vector from its own fields.
 func fitted(value: Variant, type: int) -> Variant:
 	var rebuilt: Variant = deserialize_value(value)
 	if type == TYPE_NIL or typeof(rebuilt) == type:
 		return rebuilt
 
+	if value is Dictionary and type != TYPE_DICTIONARY:
+		var fields: Dictionary = value
+		if not fields.has("_type"):
+			var tagged: Dictionary = fields.duplicate()
+			tagged["_type"] = type_string(type)
+			var built: Variant = deserialize_value(tagged)
+			if typeof(built) == type:
+				return built
+
 	if rebuilt is Array and LIST_TYPES.has(type):
 		return type_convert(rebuilt, type)
 
@@ -348,6 +362,21 @@ func fitted(value: Variant, type: int) -> Variant:
 	return type_convert(rebuilt, type)
 
 
+## 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":
+		return ""
+	var keys: Array = alternatives[0]
+	var parts: Array[String] = []
+	for key: Variant in keys:
+		parts.append('"%s": ...' % key)
+	return "{%s}" % ", ".join(parts)
+
+
 ## Whether [param fields] carries every key of any one of [param alternatives].
 ##
 ## More than one spelling because a rectangle has two: the two corners it is answered with, and the