Questions regarding bootstrapping the new Array constructors in boot.jl

nsajko · January 22, 2024, 4:53pm

These are the core constructors for Array on master:

JuliaLang/julia/blob/406f5b44725287f6a2211eb7369fe67ae089891a/base/boot.jl#L572-L592


      
          # type and dimensionality specified, accepting dims as series of Ints
          eval(Core, :(function (self::Type{Array{T,1}})(::UndefInitializer, m::Int) where {T}
              mem = fieldtype(fieldtype(self, :ref), :mem)(undef, m)
              return $(Expr(:new, :self, :(memoryref(mem)), :((m,))))
          end))
          eval(Core, :(function (self::Type{Array{T,2}})(::UndefInitializer, m::Int, n::Int) where {T}
              return $(Expr(:new, :self, :(new_as_memoryref(fieldtype(self, :ref), checked_dims(m, n))), :((m, n))))
          end))
          eval(Core, :(function (self::Type{Array{T,3}})(::UndefInitializer, m::Int, n::Int, o::Int) where {T}
              return $(Expr(:new, :self, :(new_as_memoryref(fieldtype(self, :ref), checked_dims(m, n, o))), :((m, n, o))))
          end))
          eval(Core, :(function (self::Type{Array{T, N}})(::UndefInitializer, d::Vararg{Int, N}) where {T, N}
              return $(Expr(:new, :self, :(new_as_memoryref(fieldtype(self, :ref), checked_dims(d...))), :d))
          end))
          # type and dimensionality specified, accepting dims as tuples of Ints
          (self::Type{Array{T,1}})(::UndefInitializer, d::NTuple{1, Int}) where {T} = self(undef, getfield(d, 1))
          (self::Type{Array{T,2}})(::UndefInitializer, d::NTuple{2, Int}) where {T} = self(undef, getfield(d, 1), getfield(d, 2))
          (self::Type{Array{T,3}})(::UndefInitializer, d::NTuple{3, Int}) where {T} = self(undef, getfield(d, 1), getfield(d, 2), getfield(d, 3))
          (self::Type{Array{T,N}})(::UndefInitializer, d::NTuple{N, Int}) where {T, N} = self(undef, d...)
          # type but not dimensionality specified
          Array{T}(::UndefInitializer, m::Int) where {T} = Array{T, 1}(undef, m)

The constructor methods that accept the dimensions as a series of Ints (as opposed to a tuple of Ints) come first, and they’re eval-ed into Core. Why the use of eval there, but not for the other constructor methods, below? EDIT: oh, I guess this is because they require new to be used.
I’m surprised that there’s so much code duplication? Is it necessary, or would it be possible to introduce additional helper functions to deduplicate the code?
Why use getfield(d, 1), getfield(d, 2), getfield(d, 3), instead of just d...? Is this because of some special performance considerations that affect only bootstrapping?

I’m wondering about these issues because I want to fix a bug, but fixing it seems to require adding more of these core constructor methods to base/boot.jl. Github issue:

github.com/JuliaLang/julia

Trying to construct a nonempty `<:Array{Union{}}` should throw

opened 12:59PM - 22 Jan 24 UTC

nsajko

bug collections correctness bug ⚠

```julia julia> Vector{Union{}}(undef, 1) 1-element Vector{Union{}}: #undef … ``` Two issues: 1. an array of type `<:AbstractArray{Union{}}` must always be empty (because `Union{}` never has instances). So why is the object being `show`-n as "`1-element Vector{Union{}}`"? 2. Given that `<:AbstractArray{Union{}}` can never have elements (or, more precisely I guess, `iterate` will either return `nothing` or throw), trying to construct such an array with a nonzero length should throw. The example above is by @tpapp in https://github.com/JuliaLang/julia/issues/52385#issuecomment-1903922191

Oscar_Smith · January 22, 2024, 5:16pm

I’m not 100% sure the duplication is necessary, but it might have been done to reduce the code size of the IR slightly. It would be good to check that it actually helps though.