Updates to const and global lowering; add K"constdecl"; omit wrap

JuliaLang/julia#54773, JuliaLang/julia#56713, JuliaLang/julia#57470. Some
     changes omitted from `expand-decls` and `expand-assignment`.

Note that the two-argument IR "const" is K"constdecl", whereas the one-argument
    K"const" only appears in the AST.

Also note that the `wrap` parameter is omitted throughout assignment desugaring.
      As far as I'm aware, all this plumbing was just to support `const a,b,c =
     1,2,3` having `b` and `c` inherit the `const`.  TODO: find a better way of
     doing the same thing (a ScopedValue might be a clean solution; we currently
     throw an error).

The check for `let; const x = 1; end`, (which should throw) is in scope
     analysis (lisp has it in `compile`).

Co-authored-by: Claire Foster <[email protected]>

Author: mlechu

src/closure_conversion.jl

@@ -344,11 +344,11 @@ function _convert_closures(ctx::ClosureConversionCtx, ex)
         @assert kind(ex[1]) == K"BindingId"
         binfo = lookup_binding(ctx, ex[1])
         if binfo.kind == :global
-            @ast ctx ex [K"call"
-                "set_binding_type!"::K"core"
-                binfo.mod::K"Value"
-                binfo.name::K"Symbol"
+            @ast ctx ex [
+                K"globaldecl"
+                ex[1]
                 _convert_closures(ctx, ex[2])
+                # TODO (null)?
             ]
         else
             makeleaf(ctx, ex, K"TOMBSTONE")

src/desugaring.jl

@@ -1165,16 +1165,21 @@ end
 # Expand assignments
 
 # Expand UnionAll definitions, eg `X{T} = Y{T,T}`
-function expand_unionall_def(ctx, srcref, lhs, rhs)
+function expand_unionall_def(ctx, srcref, lhs, rhs, is_const=true)
     if numchildren(lhs) <= 1
         throw(LoweringError(lhs, "empty type parameter list in type alias"))
     end
     name = lhs[1]
-    @ast ctx srcref [K"block"
-        [K"const_if_global" name]
-        unionall_type := expand_forms_2(ctx, [K"where" rhs lhs[2:end]...])
-        expand_forms_2(ctx, [K"=" name unionall_type])
-    ]
+    rr = ssavar(ctx, srcref)
+    expand_forms_2(
+        ctx,
+        @ast ctx srcref [
+            K"block"
+            [K"=" rr [K"where" rhs lhs[2:end]...]]
+            [is_const ? K"constdecl" : K"assign_const_if_global" name rr]
+            rr
+        ]
+    )
 end
 
 # Expand general assignment syntax, including
@@ -1184,13 +1189,13 @@ end
 #   * Assignments to array elements
 #   * Destructuring
 #   * Typed variable declarations
-function expand_assignment(ctx, ex)
+function expand_assignment(ctx, ex, is_const=false)
     @chk numchildren(ex) == 2
     lhs = ex[1]
     rhs = ex[2]
     kl = kind(lhs)
     if kl == K"curly"
-        expand_unionall_def(ctx, ex, lhs, rhs)
+        expand_unionall_def(ctx, ex, lhs, rhs, is_const)
     elseif kind(rhs) == K"="
         # Expand chains of assignments
         # a = b = c  ==>  b=c; a=c
@@ -1207,7 +1212,9 @@ function expand_assignment(ctx, ex)
             tmp_rhs = ssavar(ctx, rhs, "rhs")
             rr = tmp_rhs
         end
-        for i in 1:length(stmts)
+        # In const a = b = c, only a is const
+        stmts[1] = @ast ctx ex [(is_const ? K"constdecl" : K"=") stmts[1] rr]
+        for i in 2:length(stmts)
             stmts[i] = @ast ctx ex [K"=" stmts[i] rr]
         end
         if !isnothing(tmp_rhs)
@@ -1220,9 +1227,20 @@ function expand_assignment(ctx, ex)
             ]
         )
     elseif is_identifier_like(lhs)
-        sink_assignment(ctx, ex, lhs, expand_forms_2(ctx, rhs))
+        if is_const
+            rr = ssavar(ctx, rhs)
+            @ast ctx ex [
+                K"block"
+                sink_assignment(ctx, ex, rr, expand_forms_2(ctx, rhs))
+                [K"constdecl" lhs rr]
+                [K"removable" rr]
+            ]
+        else
+            sink_assignment(ctx, ex, lhs, expand_forms_2(ctx, rhs))
+        end
     elseif kl == K"."
         # a.b = rhs  ==>  setproperty!(a, :b, rhs)
+        @chk !is_const (ex, "cannot declare `.` form const")
         @chk numchildren(lhs) == 2
         a = lhs[1]
         b = lhs[2]
@@ -1250,16 +1268,24 @@ function expand_assignment(ctx, ex)
         end
     elseif kl == K"ref"
         # a[i1, i2] = rhs
+        @chk !is_const (ex, "cannot declare ref form const")
         expand_forms_2(ctx, expand_setindex(ctx, ex))
     elseif kl == K"::" && numchildren(lhs) == 2
         x = lhs[1]
         T = lhs[2]
-        res = if is_identifier_like(x)
+        res = if is_const
+            expand_forms_2(ctx, @ast ctx ex [
+                K"const"
+                [K"="
+                  lhs[1]
+                  convert_for_type_decl(ctx, ex, rhs, T, true)
+                 ]])
+        elseif is_identifier_like(x)
             # Identifer in lhs[1] is a variable type declaration, eg
             # x::T = rhs
             @ast ctx ex [K"block"
                 [K"decl" lhs[1] lhs[2]]
-                [K"=" lhs[1] rhs]
+                is_const ? [K"const" [K"=" lhs[1] rhs]] : [K"=" lhs[1] rhs]
             ]
         else
             # Otherwise just a type assertion, eg
@@ -1271,6 +1297,7 @@ function expand_assignment(ctx, ex)
             # needs to be detected somewhere but won't be detected here. Maybe
             # it shows that remove_argument_side_effects() is not the ideal
             # solution here?
+            # TODO: handle underscore?
             @ast ctx ex [K"block"
                 stmts...
                 [K"::" l1 lhs[2]]
@@ -2097,9 +2124,8 @@ function strip_decls!(ctx, stmts, declkind, declkind2, declmeta, ex)
     end
 end
 
-# local x, (y=2), z ==> local x; local y; y = 2; local z
-# const x = 1       ==> const x; x = 1
-# global x::T = 1   ==> (block (global x) (decl x T) (x = 1))
+# local x, (y=2), z ==> local x; local z; y = 2
+# Note there are differences from lisp (evaluation order?)
 function expand_decls(ctx, ex)
     declkind = kind(ex)
     declmeta = get(ex, :meta, nothing)
@@ -2129,6 +2155,58 @@ function expand_decls(ctx, ex)
     makenode(ctx, ex, K"block", stmts)
 end
 
+# Return all the names that will be bound by the assignment LHS, including
+# curlies and calls.
+function lhs_bound_names(ex)
+    k = kind(ex)
+    if k == K"Placeholder"
+        []
+    elseif is_identifier_like(ex)
+        [ex]
+    elseif k in KSet"call curly where ::"
+        lhs_bound_names(ex[1])
+    elseif k in KSet"tuple parameters"
+        vcat(map(lhs_bound_names, children(ex))...)
+    else
+        []
+    end
+end
+
+function expand_const_decl(ctx, ex)
+    function check_assignment(asgn)
+        @chk (kind(asgn) == K"=") (ex, "expected assignment after `const`")
+    end
+
+    k = kind(ex[1])
+    if numchildren(ex) == 2
+        @ast ctx ex [
+            K"constdecl"
+            ex[1]
+            expand_forms_2(ctx, ex[2])
+        ]
+    elseif k == K"global"
+        asgn = ex[1][1]
+        check_assignment(asgn)
+        globals = map(lhs_bound_names(asgn[1])) do x
+            @ast ctx ex [K"global" x]
+        end
+        @ast ctx ex [
+            K"block"
+            globals...
+            expand_assignment(ctx, ex[1], true)
+        ]
+    elseif k == K"="
+        if numchildren(ex[1]) >= 1 && kind(ex[1][1]) == K"tuple"
+            throw(LoweringError(ex[1][1], "unsupported `const` tuple"))
+        end
+        expand_assignment(ctx, ex[1], true)
+    elseif k == K"local"
+        throw(LoweringError(ex, "unsupported `const local` declaration"))
+    else
+        throw(LoweringError(ex, "expected assignment after `const`"))
+    end
+end
+
 #-------------------------------------------------------------------------------
 # Expansion of function definitions
 
@@ -3318,14 +3396,13 @@ function expand_abstract_or_primitive_type(ctx, ex)
         ]
         [K"assert" "toplevel_only"::K"Symbol" [K"inert" ex] ]
         [K"global" name]
-        [K"const" name]
         [K"if"
             [K"&&"
                 [K"isdefined" name]
                 [K"call" "_equiv_typedef"::K"core" name newtype_var]
             ]
             nothing_(ctx, ex)
-            [K"=" name newtype_var]
+            [K"constdecl" name newtype_var]
         ]
         nothing_(ctx, ex)
     ]
@@ -3827,9 +3904,10 @@ function expand_struct_def(ctx, ex, docs)
     @ast ctx ex [K"block"
         [K"assert" "toplevel_only"::K"Symbol" [K"inert" ex] ]
         [K"scope_block"(scope_type=:hard)
+            # Needed for later constdecl to work, though plain global form may be removed soon.
+            [K"global" global_struct_name]
             [K"block"
                 [K"global" global_struct_name]
-                [K"const" global_struct_name]
                 [K"local" struct_name]
                 [K"always_defined" struct_name]
                 typevar_stmts...
@@ -3868,9 +3946,9 @@ function expand_struct_def(ctx, ex, docs)
                             end
                         ]
                         # Otherwise do an assignment to trigger an error
-                        [K"=" global_struct_name struct_name]
+                        [K"const" global_struct_name struct_name]
                     ]
-                    [K"=" global_struct_name struct_name]
+                    [K"const" global_struct_name struct_name]
                 ]
                 [K"call"(type_body)
                     "_typebody!"::K"core"
@@ -4271,7 +4349,9 @@ function expand_forms_2(ctx::DesugaringContext, ex::SyntaxTree, docs=nothing)
         ]
     elseif k == K"let"
         expand_forms_2(ctx, expand_let(ctx, ex))
-    elseif k == K"local" || k == K"global" || k == K"const"
+    elseif k == K"const"
+        expand_const_decl(ctx, ex)
+    elseif k == K"local" || k == K"global"
         if numchildren(ex) == 1 && kind(ex[1]) == K"Identifier"
             # Don't recurse when already simplified - `local x`, etc
             ex

src/eval.jl

@@ -298,9 +298,10 @@ function to_lowered_expr(mod, ex, ssa_offset=0)
                k == K"splatnew"  ? :splatnew   :
                k == K"="         ? :(=)        :
                k == K"global"    ? :global     :
-               k == K"const"     ? :const      :
+               k == K"constdecl" ? :const      :
                k == K"leave"     ? :leave      :
                k == K"isdefined" ? :isdefined  :
+               k == K"globaldecl"        ? :globaldecl        :
                k == K"pop_exception"     ? :pop_exception     :
                k == K"captured_local"    ? :captured_local    :
                k == K"gc_preserve_begin" ? :gc_preserve_begin :

src/kinds.jl

@@ -96,7 +96,7 @@ function _register_kinds()
             "_opaque_closure"
             # The enclosed statements must be executed at top level
             "toplevel_butfirst"
-            "const_if_global"
+            "assign_const_if_global"
             "moved_local"
             "label"
             "trycatchelse"
@@ -121,8 +121,12 @@ function _register_kinds()
             "slot"
             # Static parameter to a `CodeInfo` code object ("type parameters" to methods)
             "static_parameter"
-            # Reference to a global variable within a module
+            # References/declares a global variable within a module
             "globalref"
+            "globaldecl"
+            # Two-argument constant declaration and assignment.
+            # Translated to :const in the IR for now (we use K"const" already in parsing).
+            "constdecl"
             # Unconditional goto
             "goto"
             # Conditional goto

src/linear_ir.jl

@@ -336,18 +336,35 @@ function emit_break(ctx, ex)
     emit_jump(ctx, ex, target)
 end
 
-function emit_assignment(ctx, srcref, lhs, rhs)
+# `op` may also be K"constdecl"
+function emit_assignment_or_setglobal(ctx, srcref, lhs, rhs, op=K"=")
+    # (const (globalref _ _) _) does not use setglobal!
+    binfo = lookup_binding(ctx, lhs.var_id)
+    if binfo.kind == :global && op == K"="
+        emit(ctx, @ast ctx srcref [
+            K"call"
+            "setglobal!"::K"top"
+            binfo.mod::K"Value"
+            binfo.name::K"Symbol"
+            rhs
+        ])
+    else
+        emit(ctx, srcref, op, lhs, rhs)
+    end
+end
+
+function emit_assignment(ctx, srcref, lhs, rhs, op=K"=")
     if !isnothing(rhs)
         if is_valid_ir_rvalue(ctx, lhs, rhs)
-            emit(ctx, srcref, K"=", lhs, rhs)
+            emit_assignment_or_setglobal(ctx, srcref, lhs, rhs, op)
         else
             r = emit_assign_tmp(ctx, rhs)
-            emit(ctx, srcref, K"=", lhs, r)
+            emit_assignment_or_setglobal(ctx, srcref, lhs, r, op)
         end
     else
         # in unreachable code (such as after return); still emit the assignment
         # so that the structure of those uses is preserved
-        emit(ctx, @ast ctx srcref [K"=" lhs "nothing"::K"core"])
+        emit_assignment_or_setglobal(ctx, srcref, lhs, @ast ctx srcref "nothing"::K"core", op)
         nothing
     end
 end
@@ -642,7 +659,7 @@ function compile(ctx::LinearIRContext, ex, needs_value, in_tail_pos)
             emit(ctx, callex)
             nothing
         end
-    elseif k == K"="
+    elseif k == K"=" || k == K"constdecl"
         lhs = ex[1]
         if kind(lhs) == K"Placeholder"
             compile(ctx, ex[2], needs_value, in_tail_pos)
@@ -651,14 +668,14 @@ function compile(ctx::LinearIRContext, ex, needs_value, in_tail_pos)
             # TODO look up arg-map for renaming if lhs was reassigned
             if needs_value && !isnothing(rhs)
                 r = emit_assign_tmp(ctx, rhs)
-                emit(ctx, ex, K"=", lhs, r)
+                emit_assignment_or_setglobal(ctx, ex, lhs, r, k)
                 if in_tail_pos
                     emit_return(ctx, ex, r)
                 else
                     r
                 end
             else
-                emit_assignment(ctx, ex, lhs, rhs)
+                emit_assignment(ctx, ex, lhs, rhs, k)
             end
         end
     elseif k == K"block" || k == K"scope_block"
@@ -813,7 +830,7 @@ function compile(ctx::LinearIRContext, ex, needs_value, in_tail_pos)
         end
     elseif k == K"gc_preserve_begin"
         makenode(ctx, ex, k, compile_args(ctx, children(ex)))
-    elseif k == K"gc_preserve_end" || k == K"global" || k == K"const"
+    elseif k == K"gc_preserve_end" || k == K"global"
         if needs_value
             throw(LoweringError(ex, "misplaced kind $k in value position"))
         end
@@ -864,6 +881,17 @@ function compile(ctx::LinearIRContext, ex, needs_value, in_tail_pos)
             # TODO: also exclude deleted vars
             emit(ctx, ex)
         end
+    elseif k == K"globaldecl"
+        if needs_value
+            throw(LoweringError(ex, "misplaced global declaration"))
+        end
+        if numchildren(ex) == 1 || is_identifier_like(ex[2])
+            emit(ctx, ex)
+        else
+            rr = ssavar(ctx, ex[2])
+            emit(ctx, @ast ctx ex [K"=" rr ex[2]])
+            emit(ctx, @ast ctx ex [K"globaldecl" ex[1] rr])
+        end
     else
         throw(LoweringError(ex, "Invalid syntax; $(repr(k))"))
     end