GDScript: Fix type compatibility check between Array[T] and Packed*Arrays

[JackErb]

Closes #94454

Verifies that, when assigning an Array to a PackedArray, that the array element is compatible with the packed array's element.

This is a potentially breaking change. Before this change, the invalid type would be converted to a default value. In this example, the packed array would silently become [(0,0), (0,0)]. This could be mitigated with a warning but I believe the proper behavior is to spout an error.

[akien-mga]

This only checks for p_target.builtin_type != Variant::ARRAY so anything that isn't an Array. That would include all other Variant types including Dictionary, float, etc., no?

Also note, once the correct approach is found here, a similar check should likely be done for typed Dictionaries just below.

[JackErb]

It's a lil confusing, but the implementation of the Variant::can_convert_strict call above here (line 6045) guarantees that if valid == true, and p_source is an ARRAY, then p_target is either an ARRAY or a PACKED_ARRAY. I will try to make this more explicit, since this could be a bug farm if the implementation of Variant::can_convert_strict changes.

[akien-mga]

Suggested change

	// don't support converting a non-static array into a packed array
	// Don't support converting a non-static array into a packed array.

[akien-mga]

Suggested change

	# these types should not be compatible
	# These types should not be compatible.

[dalexeev]

Note that this is "obvious" only for array literals with invalid elements. Instead of:

var array: PackedVector2Array
array = ["abc", "def"]

it could be:

var array: PackedVector2Array
array = [Vector2(), Vector2()]

var array: PackedVector2Array
array = [vector2_expr, vector2_expr]

var array: PackedVector2Array
array = [variant_expr, variant_expr]

var array: PackedVector2Array
array = array_expr

If the analyzer cannot guarantee that the assigned Array expression contains elements of incompatible types, then there should be no compile-time error. Instead, the conversion should be checked at runtime.

[JackErb]

If the analyzer cannot guarantee that the assigned Array expression contains elements of incompatible types, then there should be no compile-time error. Instead, the conversion should be checked at runtime.

@dalexeev That is not currently how it works when converting from Array -> Array[T]. Right now it will always fail the conversion at runtime, without checking if the element types are compatible.

Based on what you said, I think the above screenshot should succeed since the elements of vectors_untyped are all Vector2. But it fails with a runtime error.

I see two paths here. Regardless, I want to keep the behavior of Array -> Packed*Array the same as Array -> Array[T].

1. Make both of these use a runtime element conversion check.
2. Disallow Array -> Packed*Array just like Array -> Array[T] currently is, and move the error to analyze-time since it makes more sense there.

How should I proceed?

[dalexeev]

I agree that this behavior can be confusing, but there is a difference between implicit conversions Array[T] <-> Packed*Array and checking for type compatibility between Array[T1] <-> Array[T2] (including untyped arrays).

Arrays are passed by reference and untyped arrays can reference typed ones. This exception was made for compatibility with 3.x and for the convenience untyped GDScript users.

Array types check for reference compatibility. When passing Arrays you will never get an implicit copy of the array contents (instead you should explicitly use assign() if you want to copy the array contents to an array of incompatible type).

Unlike the Array[T] family, Packed*Array types are treated as fundamentally different. A Packed*Array cannot hold a reference to an Array or Packed*Array of a different type. When you assign an Array to a Packed*Array or vice versa, an implicit copy occurs, you get an independent array copy, not a reference copy.

• See also GDScript: Add IMPLICIT_CONVERSION_CAUSES_COPY warning #89853.