Track GlobalRef consistently

Currently dependencies for `GlobalRef` and `Symbol` are tracked separately.
Unfortunately, our lowering is not consistent about which one it uses (after
lowering, all `Symbols` refer to globals in the current module), so the
same variable can appear twice in the same expression, once as a globalref,
once as a symbol. Currently, in that situation, this package misses a dependency,
because it considers them two separate objects. Fix that by always normalizing
to GlobalRef. This does require the caller to pass through a Module, but
the alternative, would be for the caller to keep track of these dependencies
implicitly, which would be painful. I think consistently usign `GlobalRef`
here is cleanest.

Author: Keno

src/codeedges.jl

@@ -9,42 +9,44 @@ const NamedVar = Union{Symbol,GlobalRef}
 struct Links
     ssas::Vector{Int}
     slots::Vector{Int}
-    names::Vector{NamedVar}
+    names::Vector{GlobalRef}
 end
-Links() = Links(Int[], Int[], NamedVar[])
+Links() = Links(Int[], Int[], GlobalRef[])
 
 function Base.show(io::IO, l::Links)
     print(io, "ssas: ", showempty(l.ssas),
               ", slots: ", showempty(l.slots),
               ", names: ")
-    print(IOContext(io, :typeinfo=>Vector{NamedVar}), showempty(l.names))
+    print(IOContext(io, :typeinfo=>Vector{GlobalRef}), showempty(l.names))
     print(io, ';')
 end
 
 struct CodeLinks
+    thismod::Module
     ssapreds::Vector{Links}
     ssasuccs::Vector{Links}
     slotpreds::Vector{Links}
     slotsuccs::Vector{Links}
     slotassigns::Vector{Vector{Int}}
-    namepreds::Dict{NamedVar,Links}
-    namesuccs::Dict{NamedVar,Links}
-    nameassigns::Dict{NamedVar,Vector{Int}}
+    namepreds::Dict{GlobalRef,Links}
+    namesuccs::Dict{GlobalRef,Links}
+    nameassigns::Dict{GlobalRef,Vector{Int}}
 end
-function CodeLinks(nlines::Int, nslots::Int)
+function CodeLinks(thismod::Module, nlines::Int, nslots::Int)
     makelinks(n) = [Links() for _ = 1:n]
 
-    return CodeLinks(makelinks(nlines),
+    return CodeLinks(thismod,
+                     makelinks(nlines),
                      makelinks(nlines),
                      makelinks(nslots),
                      makelinks(nslots),
                      [Int[] for _ = 1:nslots],
-                     Dict{NamedVar,Links}(),
-                     Dict{NamedVar,Links}(),
-                     Dict{NamedVar,Vector{Int}}())
+                     Dict{GlobalRef,Links}(),
+                     Dict{GlobalRef,Links}(),
+                     Dict{GlobalRef,Vector{Int}}())
 end
-function CodeLinks(src::CodeInfo)
-    cl = CodeLinks(length(src.code), length(src.slotnames))
+function CodeLinks(thismod::Module, src::CodeInfo)
+    cl = CodeLinks(thismod, length(src.code), length(src.slotnames))
     direct_links!(cl, src)
 end
 
@@ -203,20 +205,23 @@ function direct_links!(cl::CodeLinks, src::CodeInfo)
         end
     end
 
-    P = Pair{Union{SSAValue,SlotNumber,NamedVar},Links}
+    P = Pair{Union{SSAValue,SlotNumber,GlobalRef},Links}
 
     for (i, stmt) in enumerate(src.code)
         if isexpr(stmt, :thunk) && isa(stmt.args[1], CodeInfo)
-            icl = CodeLinks(stmt.args[1])
+            icl = CodeLinks(cl.thismod, stmt.args[1])
             add_inner!(cl, icl, i)
             continue
         elseif isa(stmt, Expr) && stmt.head ∈ trackedheads
             if stmt.head === :method && length(stmt.args) === 3 && isa(stmt.args[3], CodeInfo)
-                icl = CodeLinks(stmt.args[3])
+                icl = CodeLinks(cl.thismod, stmt.args[3])
                 add_inner!(cl, icl, i)
             end
             name = stmt.args[1]
-            if isa(name, Symbol)
+            if isa(name, NamedVar)
+                if isa(name, Symbol)
+                    name = GlobalRef(cl.thismod, name)
+                end
                 assign = get(cl.nameassigns, name, nothing)
                 if assign === nothing
                     cl.nameassigns[name] = assign = Int[]
@@ -228,6 +233,10 @@ function direct_links!(cl::CodeLinks, src::CodeInfo)
                 end
                 target = P(name, targetstore)
                 add_links!(target, stmt, cl)
+            elseif name in (nothing, false)
+            else
+                @show stmt
+                error("name ", typeof(name), " not recognized")
             end
             rhs = stmt
             target = P(SSAValue(i), cl.ssapreds[i])
@@ -263,9 +272,9 @@ function direct_links!(cl::CodeLinks, src::CodeInfo)
     return cl
 end
 
-function add_links!(target::Pair{Union{SSAValue,SlotNumber,NamedVar},Links}, @nospecialize(stmt), cl::CodeLinks)
+function add_links!(target::Pair{Union{SSAValue,SlotNumber,GlobalRef},Links}, @nospecialize(stmt), cl::CodeLinks)
     _targetid, targetstore = target
-    targetid = _targetid::Union{SSAValue,SlotNumber,NamedVar}
+    targetid = _targetid::Union{SSAValue,SlotNumber,GlobalRef}
     # Adds bidirectional edges
     if @isssa(stmt)
         stmt = stmt::AnySSAValue
@@ -275,7 +284,10 @@ function add_links!(target::Pair{Union{SSAValue,SlotNumber,NamedVar},Links}, @no
         stmt = stmt::AnySlotNumber
         push!(targetstore, SlotNumber(stmt.id))
         push!(cl.slotsuccs[stmt.id], targetid)
-    elseif isa(stmt, Symbol) || isa(stmt, GlobalRef)   # NamedVar
+    elseif isa(stmt, NamedVar)   # NamedVar
+        if isa(stmt, Symbol)
+            stmt = GlobalRef(cl.thismod, stmt)
+        end
         push!(targetstore, stmt)
         namestore = get(cl.namesuccs, stmt, nothing)
         if namestore === nothing
@@ -355,7 +367,7 @@ end
 struct CodeEdges
     preds::Vector{Vector{Int}}
     succs::Vector{Vector{Int}}
-    byname::Dict{NamedVar,Variable}
+    byname::Dict{GlobalRef,Variable}
 end
 CodeEdges(n::Integer) = CodeEdges([Int[] for i = 1:n], [Int[] for i = 1:n], Dict{Union{GlobalRef,Symbol},Variable}())
 
@@ -385,8 +397,8 @@ Analyze `src` and determine the chain of dependencies.
 - `edges.byname[v]` returns information about the predecessors, successors, and assignment statements
   for an object `v::$NamedVar`.
 """
-function CodeEdges(src::CodeInfo)
-    cl = CodeLinks(src)
+function CodeEdges(mod::Module, src::CodeInfo)
+    cl = CodeLinks(mod, src)
     CodeEdges(src, cl)
 end
 
@@ -546,7 +558,7 @@ function terminal_preds(i::Int, edges::CodeEdges)
 end
 
 """
-    isrequired = lines_required(obj::$NamedVar, src::CodeInfo, edges::CodeEdges)
+    isrequired = lines_required(obj::GlobalRef, src::CodeInfo, edges::CodeEdges)
     isrequired = lines_required(idx::Int,                     src::CodeInfo, edges::CodeEdges)
 
 Determine which lines might need to be executed to evaluate `obj` or the statement indexed by `idx`.
@@ -556,9 +568,9 @@ will end up skipping a subset of such statements, perhaps while repeating others
 
 See also [`lines_required!`](@ref) and [`selective_eval!`](@ref).
 """
-function lines_required(obj::NamedVar, src::CodeInfo, edges::CodeEdges; kwargs...)
+function lines_required(obj::GlobalRef, src::CodeInfo, edges::CodeEdges; kwargs...)
     isrequired = falses(length(edges.preds))
-    objs = Set{NamedVar}([obj])
+    objs = Set{GlobalRef}([obj])
     return lines_required!(isrequired, objs, src, edges; kwargs...)
 end
 
@@ -583,7 +595,7 @@ For example, use `norequire = LoweredCodeUtils.exclude_named_typedefs(src, edges
 extracting method signatures and not evaluating new definitions.
 """
 function lines_required!(isrequired::AbstractVector{Bool}, src::CodeInfo, edges::CodeEdges; kwargs...)
-    objs = Set{NamedVar}()
+    objs = Set{GlobalRef}()
     return lines_required!(isrequired, objs, src, edges; kwargs...)
 end
 
@@ -643,7 +655,7 @@ function lines_required!(isrequired::AbstractVector{Bool}, objs, src::CodeInfo,
 end
 
 function add_requests!(isrequired, objs, edges::CodeEdges, norequire)
-    objsnew = Set{NamedVar}()
+    objsnew = Set{GlobalRef}()
     for obj in objs
         add_obj!(isrequired, objsnew, obj, edges, norequire)
     end

src/packagedef.jl

@@ -42,10 +42,10 @@ if ccall(:jl_generating_output, Cint, ()) == 1
     end
     lwr = Meta.lower(@__MODULE__, ex)
     src = lwr.args[1]
-    edges = CodeEdges(src)
-    isrequired = lines_required(:s, src, edges)
-    lines_required(:s, src, edges; norequire=())
-    lines_required(:s, src, edges; norequire=exclude_named_typedefs(src, edges))
+    edges = CodeEdges(@__MODULE__, src)
+    isrequired = lines_required(GlobalRef(@__MODULE__, :s), src, edges)
+    lines_required(GlobalRef(@__MODULE__, :s), src, edges; norequire=())
+    lines_required(GlobalRef(@__MODULE__, :s), src, edges; norequire=exclude_named_typedefs(src, edges))
     for isreq in (isrequired, convert(Vector{Bool}, isrequired))
         lines_required!(isreq, src, edges; norequire=())
         lines_required!(isreq, src, edges; norequire=exclude_named_typedefs(src, edges))

src/utils.jl

@@ -110,11 +110,20 @@ function isanonymous_typedef(stmt)
     if isa(stmt, CodeInfo)
         src = stmt    # just for naming consistency
         length(src.code) >= 4 || return false
+        local name
         @static if VERSION ≥ v"1.9.0-DEV.391"
-            stmt = src.code[end-2]
-            isexpr(stmt, :(=)) || return false
-            name = stmt.args[1]
-            isa(name, Symbol) || return false
+            for i = length(src.code)-2:-1:1
+                isexpr(stmt, :(=)) || continue
+                stmt = src.code[i]
+                name = stmt.args[1]
+                if isa(name, GlobalRef)
+                    name = name.name
+                else
+                    isa(name, Symbol) || return false
+                end
+                break
+            end
+            @isdefined(name) || return false
         else
             stmt = src.code[end-1]
             isexpr(stmt, :call) || return false