Merge pull request #4 from JuliaDebug/vc/port

Port Cthulhu to TypedCodeUtils

Author: vchuravy

.travis.yml

@@ -6,6 +6,8 @@ os:
 julia:
   - 1.0
   - 1.1
+  - 1.2
+  - 1.3
   - nightly
 notifications:
   email: false

Project.toml

@@ -3,6 +3,9 @@ uuid = "687fb87b-adea-59d5-9be9-82253b54685d"
 authors = ["Valentin Churavy <[email protected]>"]
 version = "0.1.0"
 
+[compat]
+julia = "1"
+
 [extras]
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 

src/TypedCodeUtils.jl

@@ -3,6 +3,7 @@ module TypedCodeUtils
 using Base.Meta
 import Core: Compiler
 using .Compiler: widenconst, argextype
+using Core: MethodInstance
 
 """
     Consumer
@@ -42,22 +43,16 @@ include("reflection.jl")
 # Callsite processing
 ##
 abstract type CallInfo end
-
-struct Callsite
-    id
-    callinfo::CallInfo
-end
-
-canreflect(c::Callsite) = canreflect(c.callinfo)
-reflect(c::Callsite; optimize=true, params=current_params()) = reflect(c.callinfo, optimize=optimize, params=params)
-
 include("process.jl")
+
+##
+# Reflection preprocessing
+##
 include("preprocess.jl")
 
 ##
 # Utils
 ##
-
 filter(f, code) = ((id, c) for (id, c) in enumerate(code) if f(c))
 
 """

src/process.jl

@@ -1,12 +1,15 @@
 canreflect(::CallInfo) = false
+isambiguous(::CallInfo) = false
 reflect(::CallInfo; optimize=true, params=current_params()) = nothing
 
+# Call could be resolved to a singular MI
 struct MICallInfo <: CallInfo
-    mi
+    mi::MethodInstance
     rt
 end
 canreflect(::MICallInfo) = true
-reflect(mi::MICallInfo; optimize=true, params=current_params()) = reflect(mi.mi, optimize=optimize, params=params)
+reflect(mi::MICallInfo; optimize=true, params=current_params()) =
+    reflect(mi.mi, optimize=optimize, params=params)
 
 struct BuiltinCallInfo <: CallInfo
     types
@@ -18,6 +21,8 @@ struct MultiCallInfo <: CallInfo
     rt
     callinfos::Vector{CallInfo}
 end
+isambiguous(::MultiCallInfo) = true
+Base.collect(mci::MultiCallInfo) = mci.callinfos
 
 struct GeneratedCallInfo <: CallInfo
     sig
@@ -63,23 +68,26 @@ function process_call(::Consumer, ref::Reflection, id, c)
 
     # Filter out builtin functions and intrinsic function
     if sig[1] <: Core.Builtin || sig[1] <: Core.IntrinsicFunction
-        return Callsite(id, BuiltinCallInfo(sig, rt))
+        return id, BuiltinCallInfo(sig, rt)
     end
-    return Callsite(id, callinfo(sig, rt, ref))
+    return id, callinfo(sig, rt, ref)
 end
 
 function callinfo(sig, rt, ref)
-    methds = Base._methods_by_ftype(sig, 1, ref.world)
+    methds = Base._methods_by_ftype(sig, -1, ref.world)
     (methds === false || length(methds) < 1) && return FailedCallInfo(sig, rt)
     callinfos = CallInfo[]
     for x in methds
-        meth = x[3]
         atypes = x[1]
         sparams = x[2]
+        meth = x[3]
         if isdefined(meth, :generator) && !Base.may_invoke_generator(meth, atypes, sparams)
             push!(callinfos, GeneratedCallInfo(sig, rt))
         else
-            mi = code_for_method(meth, atypes, sparams, params.world)
+            mi = code_for_method(meth, atypes, sparams, ref.world)
+            if mi === nothing
+                push!(callinfos, FailedCallInfo(sig, rt)) 
+            end
             push!(callinfos, MICallInfo(mi, rt)) 
         end
     end

src/reflection.jl

@@ -8,6 +8,12 @@ else
     sptypes_from_meth_instance(mi) = Core.Compiler.spvals_from_meth_instance(mi)
 end
 
+if VERSION >= v"1.2.0-DEV.320"
+    const may_invoke_generator = Base.may_invoke_generator
+else
+    may_invoke_generator(meth, @nospecialize(atypes), sparams) = isdispatchtuple(atypes)
+end
+
 if VERSION < v"1.2.0-DEV.573"
     code_for_method(method, metharg, methsp, world, force=false) = Core.Compiler.code_for_method(method, metharg, methsp, world, force)
 else
@@ -35,21 +41,31 @@ else
     current_params() = Core.Compiler.Params(ccall(:jl_get_world_counter, UInt, ()))
 end
 
-function reflect(F, TT; optimize=true, params=current_params())
-    sig = Tuple{typeof(F), TT.parameters...}
+function reflect(@nospecialize(F), @nospecialize(TT); optimize=true, params=current_params(), kwargs...)
+    sig = Base.signature_type(F, TT)
     reflect(sig; optimize=true, params=params)
 end
 
-function reflect(sig; optimize=true, params=current_params())
-    methds = Base._methods_by_ftype(sig, 1, params.world)
+# TODO: deduplicate with callinfo(sig, rt, ref)
+function reflect(@nospecialize(sig); optimize=true, params=current_params())
+    methds = Base._methods_by_ftype(sig, -1, params.world)
     (methds === false || length(methds) < 1) && return nothing
-    x = methds[1]
-    meth = x[3]
-    if isdefined(meth, :generator) && !isdispatchtuple(Tuple{sig.parameters[2:end]...})
-        return nothing
+    reflections = Reflection[]
+    for x in methds
+        atypes = x[1]
+        sparams = x[2]
+        meth = x[3]
+        if isdefined(meth, :generator) && !may_invoke_generator(meth, atypes, sparams)
+            continue
+        end
+        mi = code_for_method(meth, sig, x[2], params.world)
+        if mi === nothing
+            continue
+        end
+        ref = reflect(mi, optimize=optimize, params=params)
+        push!(reflections, ref)
     end
-    mi = code_for_method(meth, sig, x[2], params.world)
-    reflect(mi, optimize=optimize, params=params)
+    return reflections
 end
 
 function reflect(mi::Core.Compiler.MethodInstance; optimize=true, params=current_params())

test/runtests.jl

@@ -2,19 +2,22 @@ using TypedCodeUtils
 using Test
 
 import TypedCodeUtils: reflect, filter, lookthrough,
-                       DefaultConsumer, Reflection, Callsite,
+                       DefaultConsumer, Reflection,
                        identify_invoke, identify_call,
                        process_invoke, process_call
 
 # Test simple reflection
 f(x, y) = x + y
 
-@test reflect(f, Tuple{Int, Int}) !== nothing
-@test reflect(f, Tuple{Int, Number}) !== nothing # this probably doesn't do the right thing
-                                                 # it will give us **a** method instance. 
+@test !isempty(reflect(f, Tuple{Int, Int}))
+@test !isempty(reflect(f, Tuple{Int, Number}))
 @generated g(x, y) = :(x + y)
-@test reflect(g, Tuple{Int, Int}) !== nothing
-@test reflect(g, Tuple{Int, Number}) === nothing
+@test !isempty(reflect(g, Tuple{Int, Int}))
+if VERSION >= v"1.2.0-rc1"
+    @test !isempty(reflect(g, Tuple{Int, Number}))
+else
+    @test isempty(reflect(g, Tuple{Int, Number}))
+end
 
 # Cthulhu's inner loop
 function cthulhu(ref::Reflection)
@@ -24,17 +27,17 @@ function cthulhu(ref::Reflection)
 
     invokes = map((arg) -> process_invoke(DefaultConsumer(), ref, arg...), invokes)
     calls   = map((arg) -> process_call(  DefaultConsumer(), ref, arg...), calls)
-    
+
     callsites = append!(invokes, calls)
-    @show callsites
-    sort!(callsites, by=(c)->c.id)
+    sort!(callsites, by=(c)->first(c))
     return callsites
 end
 
 params = TypedCodeUtils.current_params()
 ref = reflect(f, Tuple{Int, Int}, params=params)
-calls = cthulhu(ref)
-nextrefs = collect(reflect(c) for c in calls if TypedCodeUtils.canreflect(c))
+@test length(ref) == 1
+calls = cthulhu(first(ref))
+nextrefs = collect(first(reflect(c)) for c in calls if TypedCodeUtils.canreflect(c[2]))
 
 function h(x)
     if x >= 2
@@ -46,8 +49,9 @@ end
 
 params = TypedCodeUtils.current_params()
 ref = reflect(h, Tuple{Int}, params=params)
-calls = cthulhu(ref)
-nextrefs = collect(reflect(c) for c in calls if TypedCodeUtils.canreflect(c))
+@test length(ref) == 1
+calls = cthulhu(first(ref))
+nextrefs = collect(first(reflect(c)) for c in calls if TypedCodeUtils.canreflect(c[2]))
 
 if VERSION >= v"1.1.0-DEV.215" && Base.JLOptions().check_bounds == 0 
 Base.@propagate_inbounds function f(x)
@@ -57,6 +61,8 @@ g(x) = @inbounds f(x)
 
 params = TypedCodeUtils.current_params()
 ref = reflect(g, Tuple{Vector{Float64}}, params=params)
+@test length(ref) == 1
+ref = first(ref)
 @show ref.CI.code
 calls = cthulhu(ref)
 @test !isempty(calls)