Move code_typed and return_types out of inference. Fix #11590

Author: yuyichao

base/inference.jl

@@ -3276,44 +3276,6 @@ function replace_getfield!(ast, e::ANY, tupname, vals, sv, i0)
     end
 end
 
-function code_typed(f, types::ANY; optimize=true)
-    types = to_tuple_type(types)
-    code_typed(call, Tuple{isa(f,Type)?Type{f}:typeof(f), types.parameters...}, optimize=optimize)
-end
-function code_typed(f::Function, types::ANY; optimize=true)
-    types = to_tuple_type(types)
-    asts = []
-    for x in _methods(f,types,-1)
-        linfo = func_for_method(x[3],types,x[2])
-        if optimize
-            (tree, ty) = typeinf(linfo, x[1], x[2], linfo, true, true)
-        else
-            (tree, ty) = typeinf_uncached(linfo, x[1], x[2], optimize=false)
-        end
-        if !isa(tree,Expr)
-            push!(asts, ccall(:jl_uncompress_ast, Any, (Any,Any), linfo, tree))
-        else
-            push!(asts, tree)
-        end
-    end
-    asts
-end
-
-function return_types(f, types::ANY)
-    types = to_tuple_type(types)
-    return_types(call, Tuple{isa(f,Type)?Type{f}:typeof(f), types.parameters...})
-end
-function return_types(f::Function, types::ANY)
-    types = to_tuple_type(types)
-    rt = []
-    for x in _methods(f,types,-1)
-        linfo = func_for_method(x[3],types,x[2])
-        (tree, ty) = typeinf(linfo, x[1], x[2])
-        push!(rt, ty)
-    end
-    rt
-end
-
 #tfunc(f,t) = methods(f,t)[1].func.code.tfunc
 
 ccall(:jl_set_typeinf_func, Void, (Any,), typeinf_ext)

base/reflection.jl

@@ -216,9 +216,45 @@ code_native(f::ANY, types::ANY) = code_native(STDOUT, f, types)
 code_native(io::IO, f::ANY, t::ANY) =
     code_native(io, call, tt_cons(isa(f, Type) ? Type{f} : typeof(f), t))
 
-if isdefined(Core, :Inference) && not_int(is(current_module(), Core.Inference))
-    code_typed(args...;kwargs...) = Core.Inference.code_typed(args...;kwargs...)
-    return_types(args...;kwargs...) = Core.Inference.return_types(args...;kwargs...)
+function code_typed(f::Function, types::ANY; optimize=true)
+    types = to_tuple_type(types)
+    asts = []
+    for x in _methods(f,types,-1)
+        linfo = Core.Inference.func_for_method(x[3],types,x[2])
+        if optimize
+            (tree, ty) = Core.Inference.typeinf(linfo, x[1], x[2], linfo,
+                                                true, true)
+        else
+            (tree, ty) = Core.Inference.typeinf_uncached(linfo, x[1], x[2],
+                                                         optimize=false)
+        end
+        if !isa(tree, Expr)
+            push!(asts, ccall(:jl_uncompress_ast, Any, (Any,Any), linfo, tree))
+        else
+            push!(asts, tree)
+        end
+    end
+    asts
+end
+
+function code_typed(f, t::ANY; optimize=true)
+    code_typed(call, tt_cons(isa(f, Type) ? Type{f} : typeof(f), t),
+               optimize=optimize)
+end
+
+function return_types(f::Function, types::ANY)
+    types = to_tuple_type(types)
+    rt = []
+    for x in _methods(f,types,-1)
+        linfo = Core.Inference.func_for_method(x[3],types,x[2])
+        (tree, ty) = Core.Inference.typeinf(linfo, x[1], x[2])
+        push!(rt, ty)
+    end
+    rt
+end
+
+function return_types(f, t::ANY)
+    return_types(call, tt_cons(isa(f, Type) ? Type{f} : typeof(f), t))
 end
 
 function which(f::ANY, t::ANY)