Add missing handling for methods defined for external method tables

Author: serenity4

src/codeedges.jl

@@ -242,27 +242,25 @@ function direct_links!(cl::CodeLinks, src::CodeInfo)
             add_inner!(cl, icl, i)
             continue
         elseif isexpr(stmt, :method)
-            if length(stmt.args) === 3 && (arg3 = stmt.args[3]; arg3 isa CodeInfo)
-                icl = CodeLinks(cl.thismod, arg3)
-                add_inner!(cl, icl, i)
-            end
-            name = stmt.args[1]
-            if isa(name, GlobalRef) || isa(name, Symbol)
+            if length(stmt.args) === 1
+                # A function with no methods was defined. Associate its new binding to it.
+                name = stmt.args[1]
                 if isa(name, Symbol)
                     name = GlobalRef(cl.thismod, name)
                 end
-                assign = get(cl.nameassigns, name, nothing)
-                if assign === nothing
-                    cl.nameassigns[name] = assign = Int[]
+                if !isa(name, GlobalRef)
+                    @show stmt
+                    error("name ", typeof(name), " not recognized")
                 end
+                assign = get!(Vector{Int}, cl.nameassigns, name)
                 push!(assign, i)
                 targetstore = get!(Links, cl.namepreds, name)
                 target = P(name, targetstore)
                 add_links!(target, stmt, cl)
-            elseif name in (nothing, false)
-            else
-                @show stmt
-                error("name ", typeof(name), " not recognized")
+            elseif length(stmt.args) === 3 && (arg3 = stmt.args[3]; arg3 isa CodeInfo) # method definition
+                # A method was defined for an existing function.
+                icl = CodeLinks(cl.thismod, arg3)
+                add_inner!(cl, icl, i)
             end
             rhs = stmt
             target = P(SSAValue(i), cl.ssapreds[i])

src/packagedef.jl

@@ -1,6 +1,6 @@
 Base.Experimental.@optlevel 1
 
-using Core: SimpleVector
+using Core: SimpleVector, MethodTable
 using Core.IR: CodeInfo, GotoIfNot, GotoNode, IR, MethodInstance, ReturnNode
 @static if isdefined(Core.IR, :EnterNode)
     using Core.IR: EnterNode

src/signatures.jl

@@ -53,7 +53,7 @@ function signature(@nospecialize(recurse), frame::Frame, @nospecialize(stmt), pc
         stmt = pc_expr(frame, pc)
     end
     isa(stmt, Expr) || return nothing, pc
-    mt = extract_method_table(frame, stmt; eval = false)
+    mt = extract_method_table(frame, stmt)
     sigsv = @lookup(frame, stmt.args[2])::SimpleVector
     sigt = signature(sigsv)
     return MethodInfoKey(mt, sigt), lastpc
@@ -189,7 +189,9 @@ function identify_framemethod_calls(frame)
             end
             msrc = stmt.args[3]
             if msrc isa CodeInfo
-                key = key::Union{GlobalRef,Bool,Nothing}
+                # XXX: Properly support interpolated `Core.MethodTable`. This will require using
+                # `stmt.args[2]` instead of `stmt.args[1]` to identify the parent function.
+                isa(key, Union{GlobalRef,Bool,Nothing}) || continue
                 for (j, mstmt) in enumerate(msrc.code)
                     isa(mstmt, Expr) || continue
                     jj = j
@@ -548,7 +550,7 @@ function methoddef!(@nospecialize(recurse), signatures::Vector{MethodInfoKey}, f
         if isa(meth, Method) && (meth.sig <: sigt && sigt <: meth.sig)
             push!(signatures, mt => meth.sig)
         else
-            if arg1 === false || arg1 === nothing
+            if arg1 === false || arg1 === nothing || isa(mt, MethodTable)
                 # If it's anonymous and not defined, define it
                 pc = step_expr!(recurse, frame, stmt, true)
                 meth = whichtt(sigt, mt)

test/signatures.jl

@@ -505,9 +505,12 @@ end
 
 end
 
+module ExternalMT
+    Base.Experimental.@MethodTable method_table
+    macro overlay(ex) esc(:(Base.Experimental.@overlay $method_table $ex)) end
+end
+
 @testset "Support for external method tables" begin
-    ExternalMT = Module()
-    Core.eval(ExternalMT, :(Base.Experimental.@MethodTable method_table))
     signatures = MethodInfoKey[]
 
     ex = :(foo(x) = "foo")
@@ -525,6 +528,15 @@ end
     @test length(signatures) == 1
     (mt, sig) = pop!(signatures)
     @test (mt, sig) === (ExternalMT.method_table, Tuple{typeof(ExternalMT.foo), Any})
+
+    ex = :(@overlay foo(x::Int64) = "overlayed foo, second edition")
+    Core.eval(ExternalMT, ex)
+    frame = Frame(ExternalMT, ex)
+    pc = methoddefs!(signatures, frame; define = false)
+    @test length(signatures) == 1
+    (mt, sig) = pop!(signatures)
+    @test (mt, sig) === (ExternalMT.method_table, Tuple{typeof(ExternalMT.foo), Int64})
+    LoweredCodeUtils.identify_framemethod_calls(frame) # make sure this does not throw
 end
 
 end # module signatures