`const` semantics changed to implicitly `global` in 1.12-DEV

[c42f]

In Julia 1.11, using const in front of a variable implied neither local nor global semantics - rather the scope was calculated according to the usual rules:

julia> Meta.@lower function f()
           const x = 1
       end
:($(Expr(:error, "unsupported `const` declaration on local variable around REPL[1]:2")))

julia> let
           const x = 1
       end
ERROR: syntax: unsupported `const` declaration on local variable around REPL[2]:2

However, in 1.12 dev, as of #54773, it seems that const implicitly implies global:

julia> Meta.@lower function f()
           const x = 1
       end
:($(Expr(:error, "`global const` declaration not allowed inside function around REPL[3]:2")))

julia> let
           const x = 1
       end
1

julia> x
1

This seems like a significant semantic change which I'm not convinced is a good idea. If one wants a global variable within a let block at top level, I think the user should explicitly declare global const x = 1 in the example above.

@Keno is this a bug or was it intentional?

[oscardssmith]

I believe this was very intentional (see #54773, #51970 and friends)

[Keno]

It is intentional that the const intermediate form is available from local scope. I'm fine retaining the error for the const syntax form, though in that case we should probably rename the syntax head for the former.

[c42f]

My main complaint here is that the following surface syntax has new semantics: x is now global but previously it was local.

let
    const x = 1
end

I don't love this - can we change it back to the old rules? Or convince me this is a good idea.

[Keno]

Yes, we can change it back.

[c42f]

It is intentional that the const intermediate form is available from local scope. I'm fine retaining the error for the const syntax form, though in that case we should probably rename the syntax head for the former.

Sure. I would like to change the IR form for const declarations.

Currently it is Expr(:const, GlobalRef(mod, varname), value) which feels uncomfortably close to the surface syntactic form Expr(:const, ...).

In JuliaLowering I'd prefer to use a dedicated head for this. We already have Expr(:globaldecl) so the obvious possibility is to have a Expr(:constdecl):

Expr(:constdecl, GlobalRef(mod, varname), value)

Alternatively, fold together Expr(:globaldecl) and Expr(:constdecl) somehow to have a single IR form for atomically declaring/initializing globals.

[MasonProtter]

One of the main things that makes me uncomfortable with this change is that a lot of people would like a local version of const such that

let 
    const x = 1
    x + 1
end

would be fine but

let 
    const x = 1
    x = x + 1
end

would error.

[xal-0]

I did not change the IR for const, but #57470 addresses this.