Allow inlining of constant return value of isdefined

Author: yuyichao

base/inference.jl

@@ -602,6 +602,10 @@ function isdefined_tfunc(args...)
                 return Const(true)
             elseif idx <= 0 || (!isvatuple(a1) && idx > fieldcount(a1))
                 return Const(false)
+            elseif !isvatuple(a1) && isbits(fieldtype(a1, idx))
+                return Const(true)
+            elseif isa(arg1, Const) && isimmutable((arg1::Const).val)
+                return Const(isdefined((arg1::Const).val, idx))
             end
         end
     end
@@ -4084,7 +4088,7 @@ function inlineable(@nospecialize(f), @nospecialize(ft), e::Expr, atypes::Vector
         if isa(e.typ, Const) # || isconstType(e.typ)
             val = e.typ.val
             if (f === apply_type || f === fieldtype || f === typeof || f === (===) ||
-                f === Core.sizeof ||
+                f === Core.sizeof || f === isdefined ||
                 istopfunction(topmod, f, :typejoin) ||
                 istopfunction(topmod, f, :isbits) ||
                 istopfunction(topmod, f, :promote_type) ||

test/inference.jl

@@ -1011,46 +1011,58 @@ function test_const_return(@nospecialize(f), @nospecialize(t), @nospecialize(val
     end
 end
 
-test_const_return(()->1, Tuple{}, 1)
-test_const_return(()->sizeof(Int), Tuple{}, sizeof(Int))
-test_const_return(()->sizeof(1), Tuple{}, sizeof(Int))
-test_const_return(()->sizeof(DataType), Tuple{}, sizeof(DataType))
-test_const_return(()->sizeof(1 < 2), Tuple{}, 1)
-@eval test_const_return(()->Core.sizeof($(Array{Int}())), Tuple{}, sizeof(Int))
-@eval test_const_return(()->Core.sizeof($(Matrix{Float32}(2, 2))), Tuple{}, 4 * 2 * 2)
-
-function find_core_sizeof_call(code)
+function find_call(code, func, narg)
     for ex in code
         isa(ex, Expr) || continue
         ex = ex::Expr
-        if ex.head === :call && length(ex.args) == 2
-            if ex.args[1] === Core.sizeof || ex.args[1] == GlobalRef(Core, :sizeof)
+        if ex.head === :call && length(ex.args) == narg
+            farg = ex.args[1]
+            if isa(farg, GlobalRef)
+                farg = farg::GlobalRef
+                if isdefined(farg.mod, farg.name) && isconst(farg.mod, farg.name)
+                    farg = getfield(farg.mod, farg.name)
+                end
+            end
+            if farg === func
                 return true
             end
         elseif Core.Inference.is_meta_expr(ex)
             continue
         end
-        find_core_sizeof_call(ex.args) && return true
+        find_call(ex.args, func, narg) && return true
     end
     return false
 end
 
+test_const_return(()->1, Tuple{}, 1)
+test_const_return(()->sizeof(Int), Tuple{}, sizeof(Int))
+test_const_return(()->sizeof(1), Tuple{}, sizeof(Int))
+test_const_return(()->sizeof(DataType), Tuple{}, sizeof(DataType))
+test_const_return(()->sizeof(1 < 2), Tuple{}, 1)
+@eval test_const_return(()->Core.sizeof($(Array{Int}())), Tuple{}, sizeof(Int))
+@eval test_const_return(()->Core.sizeof($(Matrix{Float32}(2, 2))), Tuple{}, 4 * 2 * 2)
+
 # Make sure Core.sizeof with a ::DataType as inferred input type is inferred but not constant.
 function sizeof_typeref(typeref)
     Core.sizeof(typeref[])
 end
 @test @inferred(sizeof_typeref(Ref{DataType}(Int))) == sizeof(Int)
-@test find_core_sizeof_call(first(@code_typed sizeof_typeref(Ref{DataType}())).code)
+@test find_call(first(@code_typed sizeof_typeref(Ref{DataType}())).code, Core.sizeof, 2)
 # Constant `Vector` can be resized and shouldn't be optimized to a constant.
 const constvec = [1, 2, 3]
 @eval function sizeof_constvec()
     Core.sizeof($constvec)
 end
 @test @inferred(sizeof_constvec()) == sizeof(Int) * 3
-@test find_core_sizeof_call(first(@code_typed sizeof_constvec()).code)
+@test find_call(first(@code_typed sizeof_constvec()).code, Core.sizeof, 2)
 push!(constvec, 10)
 @test @inferred(sizeof_constvec()) == sizeof(Int) * 4
 
+test_const_return((x)->isdefined(x, :re), Tuple{Complex128}, true)
+isdefined_f3(x) = isdefined(x, 3)
+@test @inferred(isdefined_f3(())) == false
+@test find_call(first(code_typed(isdefined_f3, Tuple{Tuple{Vararg{Int}}})[1]).code, isdefined, 3)
+
 let isa_tfunc = Core.Inference.t_ffunc_val[
         findfirst(Core.Inference.t_ffunc_key, isa)][3]
     @test isa_tfunc(Array, Const(AbstractArray)) === Const(true)