Autocomplete for types fails when using pick_random() on an array

[Turq-uoise]

If I have an Array[PackedScene], and I use pick_random() on it, the variable that I get sent back does not autocomplete any PackedScene functions, such as instantiate(). I assume this is because pick_random() is coded to return a Variant, but I believe that this should be returning whatever the type in the Array is.

pick_random()

showing what the autocomplete normally looks like

[Meorge]

Someone more well-versed in the GDScript engine may be able to provide more accurate insight than I can. But to my understanding, this limitation is due to some relatively fundamental parts of how GDScript/Godot is built. It'd require support for generics, which in turn would require rearchitecting a surprising amount of the GDScript engine. I think generics might be planned for an eventual GDScript rewrite/refactor soonish, but I'm not certain.

[Turq-uoise]

I would like a more in depth insight if anyone is willing, but thank you for the satisfactory answer! I guess I didn't really think about why it would be difficult, it just feels strange that it can't be done when I'm looking at it in the editor.

[Shadows-of-Fire]

Godot doesn't have generics or a straightforward type system. Array is a builtin, which means it has limited hardcoded generic support, but that has its own issues.

Nonwithstanding, I think this is still an actual bug, especially since you have declared the variable explicitly as a PackedScene. The RHS of an expression should not impact the type hints on an explicitly typed variable (Except maybe upgrading the type if its can determine with certainty that it is a stricter type).

Consider the following snippet:

We can get type hints from assigning an explicit PackedScene var to null, because our explicit variable declaration types test and that data is used for type hints and runtime checking.

Also, consider the following snippet:

This... honestly should error at parse for being so obviously wrong, but doesn't (it errors at runtime). However, it does not impact type hints. We still get them in this case.

Some behavior of Array#pick_random() is causing the type checker to break and fail to supply suggestions even on an explicitly typed variable.

These next two snippets really seem to drive that home:

If we elide the type of pick_random() by hiding it in an untyped function, we can continue to get type hints. But a direct use of pick_random() will cause the hints to be lost. If, in my example, you make _really_pick_random() return a Variant, the type hints are also lost, despite it still being a runtime error to assign a non-PackedScene to the var test.

From that analysis, it seems like the root cause is that an assignment to an explicitly-typed variable from an expression that is explicitly typed to Variant will cause the variable to lose all type hints. I don't know enough about the parser/analyzer to say why that is, though.

If you want an immediate workaround, you can do something like this for now:

func _safe_pick_random(array: Array[PackedScene]) -> PackedScene:
	return array.pick_random()

func something_else() -> void:
	var array: Array[PackedScene] = ...
	var test: PackedScene = _safe_pick_random(array) # test has proper type hints

[Turq-uoise]

Woah, this feels like a very impressive response! I don't know if that sounds patronising or not but it genuinely is interesting how you managed to cover so many edge cases (and even somehow come up with a solution for this!). Thanks a lot for the in depth explanation!

[AThousandShips]

This is already tracked in:

• Behavior of typed arrays #7364

[Shadows-of-Fire]

There's a different (potentially real) issue here though - the following snippet will cause you to lose type hints indefinitely for the scope of the variable:

var thing: SomeClass = null
thing = some_method_that_returns_a_variant() # Method return type must explicitly be Variant
# thing has no autocomplete

That doesn't sound intentional, especially since it doesn't change the fact that the runtime behavior of thing still only permits assignments from subclasses of SomeClass.

[dalexeev]

It seems we already fixed this editor bug, but it appeared again? CC @HolonProduction

[HolonProduction]

That's fixed in the 4.5 beta 4. See godotengine/godot#92584

[Mickeon]

Does it mean that this "proposal" (which mostly is describing a bug) has been implemented?

[HolonProduction]

I think so. At least everything that is not already mentioned in #7364

[Calinou]

Closing, as this was fixed by godotengine/godot#92584 (and is actually a bug, rather than a missing feature; see #7364).