support type annotations on global variables

[simeonschaub]

This is an initial proposal for supporting typed globals based on #43455.
The syntax for this is either global x::T or just doing x::T = 1 in
global scope. It is even supported to add these annotations to globals
from inside functions. The type declaration will then be applied when
the method is defined and inside the function body conversion to the
specified type will happen automatically, similar to type annotations
for local variables.

This conversion will not be applied if the assignment is not done inside
the same scope of the type annotation however. This could potentially be
supported as well, but the problem is that this would mean any
assignment to a global variable - typed or not - would need to go
through a call to convert first, since lowering can't know if a given
binding already has a type annotation. This probably wouldn't be a good
thing for latency and sysimage size and would add an invalidation risk.

Any assignment to a global now adds a conversion step and a type
assertion, similar to how type annotations work inside local scopes.

It is allowed to refine a type annotation, but there will be a warning.
Widening the type or changing it to any other type that is not a subtype
of the previous one is an error, since that could cause cached compiled
code to become invalid.

replaces #43455
closes #964

[JeffBezanson]

This conversion will not be applied if the assignment is not done inside
the same scope of the type annotation however. This could potentially be
supported as well

I think we will need to support this. Users would expect to write x::Int = 0 at the top level once, and have that apply everywhere. I know it's a bit annoying, which is why we haven't done this yet 😄 But assigning to globals should already be quite rare and slow, so the extra convert call is fine with me.

[KristofferC]

It is even supported to add these annotations to globals
from inside functions. The type declaration will then be applied when
the method is defined and inside the function body conversion to the
specified type will happen automatically, similar to type annotations
for local variables.

That seems like a quite weird feature to me. Was this implemented because it was easy or does it have some good use cases?

[simeonschaub]

We could disallow adding these type annotations inside local scopes, but since we already allow defining new globals from local scopes, I think it's only consistent to allow declaring new typed ones as well. This was a bit of a special case before my last commit, since lowering would then use that annotation to add the automatic conversion. Now, this automatic conversion is always added on assignments to globals though, so there's not really much special handling except that we explicitly tell lowering to always set binding types from the toplevel via the toplevel-bufirst expression head.

[antoine-levitt]

Very cool, great feature! Is this limited to literal types, or will it be possible to do T = Int32; x::T? If so, we could introduce a @typeconst macro (or even language keyword?) and have @typeconst x=2 lower to temp = 2; x::typeof(temp) = temp; that would get rid of the most common reason for the misuse of const (at least for me). (then, in a perfect world, it would be allowed to redefine the type of global variables, and finally have performant and flexible global variables...)

[simeonschaub]

Is this limited to literal types, or will it be possible to do T = Int32; x::T?

Any valid top level expression is fine.

I'm not sure we need such a @typeconst macro in base, but that can always be discussed in a future issue/PR.

[simeonschaub]

/buildkite rerun failed