Cleanup: Use issingletontype consistently

Rather than reaching for `isdefined(x, :instance)`. They are currently
equivalent, but I was playing with an extension that would have made them
not be. I don't currently have plans to finish that particular PR, but
this cleanup seems good regardless to specify exactly what is meant
rather than reaching for the implementation.

Author: Keno

base/compiler/abstractinterpretation.jl

@@ -1640,7 +1640,7 @@ function abstract_call_builtin(interp::AbstractInterpreter, f::Builtin, (; fargs
                     bty = widenconditional(bty)
                 elseif rt === Const(true)
                     bty = Union{}
-                elseif bty isa Type && isdefined(typeof(aty.val), :instance) # can only widen a if it is a singleton
+                elseif bty isa Type && issingletontype(typeof(aty.val)) # can only widen a if it is a singleton
                     bty = typesubtract(bty, typeof(aty.val), InferenceParams(interp).MAX_UNION_SPLITTING)
                 else
                     bty = widenconditional(bty)
@@ -1653,7 +1653,7 @@ function abstract_call_builtin(interp::AbstractInterpreter, f::Builtin, (; fargs
                     aty = widenconditional(aty)
                 elseif rt === Const(true)
                     aty = Union{}
-                elseif aty isa Type && isdefined(typeof(bty.val), :instance) # same for b
+                elseif aty isa Type && issingletontype(typeof(bty.val)) # same for b
                     aty = typesubtract(aty, typeof(bty.val), InferenceParams(interp).MAX_UNION_SPLITTING)
                 else
                     aty = widenconditional(aty)

base/compiler/inferenceresult.jl

@@ -150,7 +150,7 @@ function most_general_argtypes(method::Union{Method, Nothing}, @nospecialize(spe
                 end
                 for i in 1:length(vargtype_elements)
                     atyp = vargtype_elements[i]
-                    if isa(atyp, DataType) && isdefined(atyp, :instance)
+                    if issingletontype(atyp)
                         # replace singleton types with their equivalent Const object
                         vargtype_elements[i] = Const(atyp.instance)
                     elseif isconstType(atyp)
@@ -179,7 +179,7 @@ function most_general_argtypes(method::Union{Method, Nothing}, @nospecialize(spe
                 tail_index -= 1
             end
             atyp = unwraptv(atyp)
-            if isa(atyp, DataType) && isdefined(atyp, :instance)
+            if issingletontype(atyp)
                 # replace singleton types with their equivalent Const object
                 atyp = Const(atyp.instance)
             elseif isconstType(atyp)

base/compiler/tfuncs.jl

@@ -251,8 +251,8 @@ function egal_tfunc(::ConstsLattice, @nospecialize(x), @nospecialize(y))
         return Const(x.val === y.val)
     elseif !hasintersect(widenconst(x), widenconst(y))
         return Const(false)
-    elseif (isa(x, Const) && y === typeof(x.val) && isdefined(y, :instance)) ||
-           (isa(y, Const) && x === typeof(y.val) && isdefined(x, :instance))
+    elseif (isa(x, Const) && y === typeof(x.val) && issingletontype(x)) ||
+           (isa(y, Const) && x === typeof(y.val) && issingletontype(y))
         return Const(true)
     end
     return Bool
@@ -1739,7 +1739,7 @@ function tuple_tfunc(@specialize(lattice::AbstractLattice), argtypes::Vector{Any
     end
     typ = Tuple{params...}
     # replace a singleton type with its equivalent Const object
-    isdefined(typ, :instance) && return Const(typ.instance)
+    issingletontype(typ) && return Const(typ.instance)
     return anyinfo ? PartialStruct(typ, argtypes) : typ
 end
 tuple_tfunc(argtypes::Vector{Any}) = tuple_tfunc(fallback_lattice, argtypes)

base/compiler/typelattice.jl

@@ -320,7 +320,7 @@ function ⊑(lattice::ConstsLattice, @nospecialize(a), @nospecialize(b))
         # most conservative option.
         return isa(b, Type) && isa(a.val, b)
     elseif isa(b, Const)
-        if isa(a, DataType) && isdefined(a, :instance)
+        if issingletontype(a)
             return a.instance === b.val
         end
         return false

base/compiler/typeutils.jl

@@ -55,7 +55,7 @@ function has_nontrivial_const_info(lattice::ConstsLattice, @nospecialize t)
     isa(t, PartialTypeVar) && return true
     if isa(t, Const)
         val = t.val
-        return !isdefined(typeof(val), :instance) && !(isa(val, Type) && hasuniquerep(val))
+        return !issingletontype(typeof(val)) && !(isa(val, Type) && hasuniquerep(val))
     end
     return has_nontrivial_const_info(widenlattice(lattice), t)
 end

base/compiler/utilities.jl

@@ -295,15 +295,15 @@ function singleton_type(@nospecialize(ft))
         return ft.val
     elseif isconstType(ft)
         return ft.parameters[1]
-    elseif ft isa DataType && isdefined(ft, :instance)
+    elseif issingletontype(ft)
         return ft.instance
     end
     return nothing
 end
 
 function maybe_singleton_const(@nospecialize(t))
     if isa(t, DataType)
-        if isdefined(t, :instance)
+        if issingletontype(t)
             return Const(t.instance)
         elseif isconstType(t)
             return Const(t.parameters[1])

base/summarysize.jl

@@ -77,7 +77,7 @@ end
 (ss::SummarySize)(@nospecialize obj) = _summarysize(ss, obj)
 # define the general case separately to make sure it is not specialized for every type
 @noinline function _summarysize(ss::SummarySize, @nospecialize obj)
-    isdefined(typeof(obj), :instance) && return 0
+    issingletontype(typeof(obj)) && return 0
     # NOTE: this attempts to discover multiple copies of the same immutable value,
     # and so is somewhat approximate.
     key = ccall(:jl_value_ptr, Ptr{Cvoid}, (Any,), obj)

stdlib/Serialization/src/Serialization.jl

@@ -1323,7 +1323,7 @@ function deserialize_typename(s::AbstractSerializer, number)
         tn.max_methods = maxm
         if has_instance
             ty = ty::DataType
-            if !isdefined(ty, :instance)
+            if !Base.issingletontype(ty)
                 singleton = ccall(:jl_new_struct, Any, (Any, Any...), ty)
                 # use setfield! directly to avoid `fieldtype` lowering expecting to see a Singleton object already on ty
                 ccall(:jl_set_nth_field, Cvoid, (Any, Csize_t, Any), ty, Base.fieldindex(DataType, :instance)-1, singleton)

test/compiler/contextual.jl

@@ -70,7 +70,7 @@ module MiniCassette
     end
 
     function overdub_generator(self, c, f, args)
-        if !isdefined(f, :instance)
+        if !Base.issingletontype(f)
             return :(return f(args...))
         end
 

test/core.jl

@@ -4870,8 +4870,8 @@ end
 let a = Val{Val{TypeVar(:_, Int)}},
     b = Val{Val{x} where x<:Int}
 
-    @test !isdefined(a, :instance)
-    @test  isdefined(b, :instance)
+    @test !Base.issingletontype(a)
+    @test  Base.issingletontype(b)
     @test Base.isconcretetype(b)
 end