Make allocatedinline public and give it a docstring

base/array.jl

@@ -187,24 +187,6 @@ end
 
 asize_from(a::Array, n) = n > ndims(a) ? () : (size(a,n), asize_from(a, n+1)...)
 
-allocatedinline(@nospecialize T::Type) = (@_total_meta; ccall(:jl_stored_inline, Cint, (Any,), T) != Cint(0))
-
-"""
-    Base.isbitsunion(::Type{T})
-
-Return whether a type is an "is-bits" Union type, meaning each type included in a Union is [`isbitstype`](@ref).
-
-# Examples
-```jldoctest
-julia> Base.isbitsunion(Union{Float64, UInt8})
-true
-
-julia> Base.isbitsunion(Union{Float64, String})
-false
-```
-"""
-isbitsunion(u::Type) = u isa Union && allocatedinline(u)
-
 function _unsetindex!(A::Array, i::Int)
     @inline
     @boundscheck checkbounds(A, i)

base/genericmemory.jl

@@ -422,3 +422,65 @@ function replaceindex_atomic!(
         @_boundscheck,
     )
 end
+
+"""
+     allocatedinline(::Type{T}) :: Bool
+
+Returns whether an object of type `T` is able to be inline allocated inside of enclosing structs or arrays,
+of if it must be allocated as a reference. Generally, types which are immutable and whose instances have a
+finite, statically determinable size can be allocated inline, whereas everything else is allocated using
+reference pointers.
+
+# Examples
+```jldoctest
+julia> Base.allocatedinline(Int)
+true
+
+julia> Base.allocatedinline(Union{Int, Float64})
+true
+
+julia> Base.allocatedinline(Complex)
+false
+
+julia> Base.allocatedinline(Complex{Int})
+true
+```
+
+Whether or not a type is `allocatedinline` determines whether or not objects of that type can be undefined
+in arrays or as fields of enclosing types, or if it will be replaced with garbage bits read from memory.
+```
+julia> Vector{Int}(undef, 1)
+1-element Vector{Int64}:
+ 8
+
+julia> Vector{Union{Int, Float64}}(undef, 1)
+1-element Vector{Union{Float64, Int64}}:
+ 0.0
+
+julia> Vector{Complex}(undef, 1)
+1-element Vector{Complex}:
+ #undef
+
+julia> Vector{Complex{Int}}(undef, 1)
+1-element Vector{Complex{Int64}}:
+ 139934851180016 + 7957332965790215680im
+```
+See also [`isdefined`](@ref), [`isassigned`](@ref)
+"""
+allocatedinline(@nospecialize T::Type) = (@_total_meta; ccall(:jl_stored_inline, Cint, (Any,), T) != Cint(0))
+
+"""
+    Base.isbitsunion(::Type{T})
+
+Return whether a type is an "is-bits" Union type, meaning each type included in a Union is [`isbitstype`](@ref).
+
+# Examples
+```jldoctest
+julia> Base.isbitsunion(Union{Float64, UInt8})
+true
+
+julia> Base.isbitsunion(Union{Float64, String})
+false
+```
+"""
+isbitsunion(u::Type) = u isa Union && allocatedinline(u)

base/public.jl

@@ -69,6 +69,7 @@ public
     isexported,
     ispublic,
     remove_linenums!,
+    allocatedinline,
 
 # AST handling
     IR,