Fixes for global and local decls in value position (JuliaLang/JuliaLowering.jl#67)

Disallows "use" of the value of `global x`, except in tail position in
top level thunks - in those cases, return `nothing` so that `global x`
can be used nested within of a top level thunk as long as it's "statement like".
This is normally harmless as one cannot observe the value from tail position
except in special circumstances - namely the return value of `eval()`
(and things which call eval, such as `include()`). It's a conservative relaxation
of the current rules where globals in value position are only allowed in top
level code if they're not nested in other syntax.

While we're thinking about this, also disallow a bare `local x` in a top
level thunk because this cannot have useful side effects and is just
confusing when it occurs outside a block construct. (This is not
currently disallowed for `local` arising from macro expansions because
it's not an obvious user error in that case. It could possibly arise as
a valid macro expansion of a trivial case, for some macros?)

Author: c42f

JuliaLowering/src/kinds.jl

@@ -117,6 +117,8 @@ function _register_kinds()
             # (That is, it's removable in the same sense as
             #  `@assume_effects :removable`.)
             "removable"
+            # Variable type declaration; `x::T = rhs` will be temporarily
+            # desugared to include `(decl x T)`
             "decl"
             # [K"captured_local" index]
             # A local variable captured into a global method. Contains the

JuliaLowering/src/linear_ir.jl

@@ -792,12 +792,20 @@ function compile(ctx::LinearIRContext, ex, needs_value, in_tail_pos)
         emit(ctx, ex)
         nothing
     elseif k == K"global"
-        if needs_value
-            throw(LoweringError(ex, "misplaced global declaration in value position"))
-        end
         emit(ctx, ex)
         ctx.is_toplevel_thunk && emit_latestworld(ctx, ex)
-        nothing
+        if needs_value
+            if in_tail_pos && ctx.is_toplevel_thunk
+                # Permit "statement-like" globals at top level but potentially
+                # inside blocks.
+                compile(ctx, nothing_(ctx, ex), needs_value, in_tail_pos)
+            else
+                throw(LoweringError(ex,
+                    "global declaration doesn't read the variable and can't return a value"))
+            end
+        else
+            nothing
+        end
     elseif k == K"meta"
         emit(ctx, ex)
         if needs_value

JuliaLowering/src/macro_expansion.jl

@@ -461,6 +461,11 @@ function expand_forms_1(ctx::MacroExpansionContext, ex::SyntaxTree)
 end
 
 @fzone "JL: macroexpand" function expand_forms_1(mod::Module, ex::SyntaxTree, expr_compat_mode::Bool, macro_world::UInt)
+    if kind(ex) == K"local"
+        # This error assumes we're expanding the body of a top level thunk but
+        # we might want to make that more explicit in the pass system.
+        throw(LoweringError(ex, "local declarations have no effect outside a scope"))
+    end
     graph = ensure_attributes(syntax_graph(ex),
                               var_id=IdTag,
                               scope_layer=LayerId,

JuliaLowering/src/scope_analysis.jl

@@ -427,7 +427,10 @@ function _resolve_scopes(ctx, ex::SyntaxTree)
     # elseif k == K"global"
     #     ex
     elseif k == K"local"
-        makeleaf(ctx, ex, K"TOMBSTONE")
+        # Local declarations have a value of `nothing` according to flisp
+        # lowering.
+        # TODO: Should local decls be disallowed in value position?
+        @ast ctx ex "nothing"::K"core"
     elseif k == K"decl"
         ex_out = mapchildren(e->_resolve_scopes(ctx, e), ctx, ex)
         name = ex_out[1]

JuliaLowering/test/decls.jl

@@ -11,9 +11,14 @@ end
 
 # In value position, yield the right hand side, not `x`
 @test JuliaLowering.include_string(test_mod, """
-local x::Int = 1.0
+begin
+    local x::Int = 1.0
+end
 """) === 1.0
 
+# Global decl in value position without assignment returns nothing
+@test JuliaLowering.include_string(test_mod, "global x_no_assign") === nothing
+
 # Unadorned declarations
 @test JuliaLowering.include_string(test_mod, """
 let

JuliaLowering/test/decls_ir.jl

@@ -1,6 +1,8 @@
 ########################################
 # Local declaration with type
-local x::T = 1
+begin
+    local x::T = 1
+end
 #---------------------
 1   (newvar slot₁/x)
 2   1
@@ -17,6 +19,74 @@ local x::T = 1
 13  (= slot₁/x %₁₂)
 14  (return %₂)
 
+########################################
+# Error: Local declarations outside a scope are disallowed
+# See https://github.com/JuliaLang/julia/issues/57483
+local x
+#---------------------
+LoweringError:
+local x
+└─────┘ ── local declarations have no effect outside a scope
+
+########################################
+# Local declaration allowed in tail position
+begin
+    local x
+end
+#---------------------
+1   (newvar slot₁/x)
+2   (return core.nothing)
+
+########################################
+# Local declaration allowed in value position
+# TODO: This may be a bug in flisp lowering - should we reconsider this?
+let
+    y = local x
+end
+#---------------------
+1   (newvar slot₁/x)
+2   core.nothing
+3   (= slot₂/y %₂)
+4   (return %₂)
+
+########################################
+# Global declaration allowed in tail position
+global x
+#---------------------
+1   (global TestMod.x)
+2   latestworld
+3   (return core.nothing)
+
+########################################
+# Global declaration allowed in tail position, nested
+begin
+    global x
+end
+#---------------------
+1   (global TestMod.x)
+2   latestworld
+3   (return core.nothing)
+
+########################################
+# Error: Global declaration not allowed in tail position in functions
+function f()
+    global x
+end
+#---------------------
+LoweringError:
+function f()
+    global x
+#          ╙ ── global declaration doesn't read the variable and can't return a value
+end
+
+########################################
+# Error: Global declaration not allowed in value position
+y = global x
+#---------------------
+LoweringError:
+y = global x
+#          ╙ ── global declaration doesn't read the variable and can't return a value
+
 ########################################
 # const
 const xx = 10