Add a way to clarify ambiguous classinfos

[Pikachu920]

I would like propose adding a syntax to clarify ambiguous type literals in Skript.

Currently, certain words can refer to multiple types, which can lead to confusion and errors in scripting. For instance, black could refer to a color or a variant of a wolf. Horrifically, unknown has over ten different matching types. This ambiguity can make it impossible for the parser to understand the intended meaning, especially in complex scripts.

To address this issue, I suggest introducing a syntax that allows users to specify the type explicitly by using the pattern <.+> (%classinfo%). For example: black (the wolf variant). This would clearly indicate to the parser that we are referring to the wolf variant rather than the color. We could even take it a step further and allow users to opt into a mode which forces them to specify the type when a type literal is ambiguous.

My guess is that adding support for this directly to the type literal parser itself would be best. I worry that implementing it as an expression might affect parse times, but I would love more thoughts on that.

[sovdeeth]

i agree with your thoughts about it being part of the literal parser and i like the overall idea
I think we should still look into more comprehensive solutions like type deduction (if possible in the future), but I think this is probably the best short-term solution

[Fusezion]

I'm just strongly against the design of <.+> (%classinfo%) this doesn't from my perspective help make things understandable, I love the idea of a proposed solution but the syntax is not something I can agree with, it doesn't portray an easy to understand usage of inferring the type. More so I would rather see an English word than symbols even just kotlin's <.+> as %classinfo% would be better, however I understand there's likely some parse time concerns