adjustments to v1.12

There have been changes to type definitions and global variable
assignments to v1.12, and this commit tries to adjust the code base to
it. There might be some missing pieces still, this allow us to reduce
the failures in the test suite.

Author: aviatesk

src/codeedges.jl

@@ -163,8 +163,10 @@ function postprint_linelinks(io::IO, idx::Int, src::CodeInfo, cl::CodeLinks, bbc
     printstyled(io, bbchanged ? " " : "│", color=:light_black)
     printstyled(io, "             # ", color=:yellow)
     stmt = src.code[idx]
-    if is_assignment_like(stmt)
-        lhs = normalize_defsig(stmt.args[1], cl.thismod)
+    lhs_rhs = get_lhs_rhs(stmt)
+    if lhs_rhs !== nothing
+        lhs, _ = lhs_rhs
+        lhs = normalize_defsig(lhs, cl.thismod)
         if @issslotnum(lhs)
             # id = lhs.id
             # preds, succs = cl.slotpreds[id], cl.slotsuccs[id]
@@ -190,8 +192,27 @@ function namedkeys(cl::CodeLinks)
     return ukeys
 end
 
-is_assignment_like(stmt::Expr) = isexpr(stmt, :(=)) || (isexpr(stmt, :const) && length(stmt.args) == 2)
-is_assignment_like(@nospecialize stmt) = false
+function get_lhs_rhs(@nospecialize stmt)
+    if isexpr(stmt, :(=))
+        return Pair{Any,Any}(stmt.args[1], stmt.args[2])
+    elseif isexpr(stmt, :const) && length(stmt.args) == 2
+        return Pair{Any,Any}(stmt.args[1], stmt.args[2])
+    elseif isexpr(stmt, :call) && length(stmt.args) == 4
+        f = stmt.args[1]
+        if isa(f, GlobalRef) && f.name === :setglobal!
+            mod = stmt.args[2]
+            mod isa Module || return nothing
+            name = stmt.args[3]
+            if name isa QuoteNode
+                name = name.value
+            end
+            name isa Symbol || return nothing
+            lhs = GlobalRef(mod, name)
+            return Pair{Any,Any}(lhs, stmt.args[4])
+        end
+    end
+    return nothing
+end
 
 function direct_links!(cl::CodeLinks, src::CodeInfo)
     # Utility for when a stmt itself contains a CodeInfo
@@ -247,10 +268,10 @@ function direct_links!(cl::CodeLinks, src::CodeInfo)
             end
             rhs = stmt
             target = P(SSAValue(i), cl.ssapreds[i])
-        elseif is_assignment_like(stmt)
+        elseif (lhs_rhs = get_lhs_rhs(stmt); lhs_rhs !== nothing)
             # An assignment
             stmt = stmt::Expr
-            lhs, rhs = stmt.args[1], stmt.args[2]
+            lhs, rhs = lhs_rhs
             if @issslotnum(lhs)
                 lhs = lhs::AnySlotNumber
                 id = lhs.id
@@ -423,9 +444,9 @@ function CodeEdges(src::CodeInfo, cl::CodeLinks)
     emptylist = Int[]
     for (i, stmt) in enumerate(src.code)
         # Identify line predecents for slots and named variables
-        if is_assignment_like(stmt)
+        if (lhs_rhs = get_lhs_rhs(stmt); lhs_rhs !== nothing)
             stmt = stmt::Expr
-            lhs = stmt.args[1]
+            lhs, _ = lhs_rhs
             # Mark predecessors and successors of this line by following ssas & named assignments
             if @issslotnum(lhs)
                 lhs = lhs::AnySlotNumber
@@ -611,7 +632,7 @@ function exclude_named_typedefs(src::CodeInfo, edges::CodeEdges)
     i = 1
     nstmts = length(src.code)
     while i <= nstmts
-        stmt = rhs(src.code[i])
+        stmt = getrhs(src.code[i])
         if istypedef(stmt) && !isanonymous_typedef(stmt::Expr)
             r = typedef_range(src, i)
             pushall!(norequire, r)
@@ -871,7 +892,7 @@ function find_typedefs(src::CodeInfo)
     i = 1
     nstmts = length(src.code)
     while i <= nstmts
-        stmt = rhs(src.code[i])
+        stmt = getrhs(src.code[i])
         if istypedef(stmt) && !isanonymous_typedef(stmt::Expr)
             stmt = stmt::Expr
             r = typedef_range(src, i)
@@ -972,8 +993,8 @@ function add_inplace!(isrequired, src, edges, norequire)
                     for k in edges.preds[j]
                         isrequired[k] || continue
                         predstmt = src.code[k]
-                        if is_assignment_like(predstmt)
-                            lhs = predstmt.args[1]
+                        if (lhs_rhs = get_lhs_rhs(predstmt); lhs_rhs !== nothing)
+                            lhs, _ = lhs_rhs
                             if @issslotnum(lhs) && lhs.id == id
                                 changed |= mark_if_inplace(stmt, j)
                                 break

src/utils.jl

@@ -58,9 +58,9 @@ function callee_matches(f, mod, sym)
     return false
 end
 
-function rhs(stmt)
-    is_assignment_like(stmt) && return (stmt::Expr).args[2]
-    return stmt
+function getrhs(@nospecialize(stmt))
+    lhs_rhs = get_lhs_rhs(stmt)
+    return lhs_rhs === nothing ? stmt : lhs_rhs[2]
 end
 
 ismethod(frame::Frame)  = ismethod(pc_expr(frame))
@@ -107,7 +107,7 @@ function ismethod_with_name(src, stmt, target::AbstractString; reentrant::Bool=f
 end
 
 # anonymous function types are defined in a :thunk expr with a characteristic CodeInfo
-function isanonymous_typedef(stmt)
+function isanonymous_typedef(@nospecialize stmt)
     if isa(stmt, Expr)
         stmt.head === :thunk || return false
         stmt = stmt.args[1]
@@ -119,21 +119,22 @@ function isanonymous_typedef(stmt)
         isexpr(stmt, :call) || return false
         is_global_ref(stmt.args[1], Core, :_typebody!) || return false
         stmt = isa(stmt.args[3], Core.SSAValue) ? src.code[end-3] : src.code[end-2]
-        is_assignment_like(stmt) || return false
-        name = stmt.args[1]
-        if isa(name, GlobalRef)
-            name = name.name
+        lhs_rhs = get_lhs_rhs(stmt)
+        lhs_rhs === nothing && return false
+        lhs, _ = lhs_rhs
+        if isa(lhs, GlobalRef)
+            lhs = lhs.name
         else
-            isa(name, Symbol) || return false
+            isa(lhs, Symbol) || return false
         end
-        return startswith(String(name), "#")
+        return startswith(String(lhs), "#")
     end
     return false
 end
 
 function istypedef(stmt)
     isa(stmt, Expr) || return false
-    stmt = rhs(stmt)
+    stmt = getrhs(stmt)
     isa(stmt, Expr) || return false
     @static if all(s->isdefined(Core,s), structdecls)
         if stmt.head === :call
@@ -162,6 +163,7 @@ function typedef_range(src::CodeInfo, idx)
     istart = idx
     while istart >= 1
         isexpr(src.code[istart], :global) && break
+        isexpr(src.code[istart], :latestworld) && break
         istart -= 1
     end
     istart >= 1 || error("no initial :global found")
@@ -171,6 +173,7 @@ function typedef_range(src::CodeInfo, idx)
         stmt = src.code[iend]
         if isa(stmt, Expr)
             stmt.head === :global && break
+            stmt.head === :latestworld && break
             if stmt.head === :call
                 if (is_global_ref(stmt.args[1], Core, :_typebody!) || is_quotenode_egal(stmt.args[1], Core._typebody!))
                     have_typebody = true
@@ -179,7 +182,7 @@ function typedef_range(src::CodeInfo, idx)
                     # Advance to the type-assignment
                     while iend <= n
                         stmt = src.code[iend]
-                        is_assignment_like(stmt) && break
+                        get_lhs_rhs(stmt) !== nothing && break
                         iend += 1
                     end
                 end

test/codeedges.jl

@@ -414,9 +414,8 @@ module ModSelective end
 end
 
 @testset "selective interpretation of toplevel definitions" begin
-    gen_mock_module() = Core.eval(@__MODULE__, :(module $(gensym(:LoweredCodeUtilsTestMock)) end))
     function check_toplevel_definition_interprete(ex, defs, undefs)
-        m = gen_mock_module()
+        m = Module(:LoweredCodeUtilsTestMock)
         lwr = Meta.lower(m, ex)
         src = first(lwr.args)
         stmts = src.code
@@ -426,8 +425,8 @@ end
         frame = Frame(m, src)
         selective_eval_fromstart!(frame, isrq, #=toplevel=#true)
 
-        for def in defs; @test isdefined(m, def); end
-        for undef in undefs; @test !isdefined(m, undef); end
+        for def in defs; @test @invokelatest(isdefined(m, def)); end
+        for undef in undefs; @test !@invokelatest(isdefined(m, undef)); end
     end
 
     @testset "case: $(i), interpret: $(defs), ignore $(undefs)" for (i, ex, defs, undefs) in (