Support for empty constant arrays and structs.

Author: maleadt

src/core/value/constant.jl

@@ -102,8 +102,14 @@ export ConstantAggregateZero
 end
 identify(::Type{Value}, ::Val{API.LLVMConstantAggregateZeroValueKind}) = ConstantAggregateZero
 
-# there currently seems to be no function in the LLVM-C interface which returns a
-# ConstantAggregateZero value directly, but values can occur through calls to LLVMConstNull
+# array interface
+# FIXME: can we reuse the ::ConstantArray functionality with ConstantAggregateZero values?
+#        probably works fine if we just get rid of the refcheck
+Base.eltype(caz::ConstantAggregateZero) = eltype(llvmtype(caz))
+Base.size(caz::ConstantAggregateZero) = (0,)
+Base.length(caz::ConstantAggregateZero) = 0
+Base.axes(caz::ConstantAggregateZero) = (Base.OneTo(0),)
+Base.collect(caz::ConstantAggregateZero) = Value[]
 
 
 ## regular aggregate
@@ -118,13 +124,15 @@ end
 identify(::Type{Value}, ::Val{API.LLVMConstantArrayValueKind}) = ConstantArray
 identify(::Type{Value}, ::Val{API.LLVMConstantDataArrayValueKind}) = ConstantArray
 
+ConstantArrayOrAggregateZero(value) = Value(value)::Union{ConstantArray,ConstantAggregateZero}
+
 # generic constructor taking an array of constants
 function ConstantArray(data::AbstractArray{<:Constant,N},
                        typ::LLVMType=llvmtype(first(data))) where {N}
     @assert all(x->x==typ, llvmtype.(data))
 
     if N == 1
-        return ConstantArray(API.LLVMConstArray(typ, Array(data), length(data)))
+        return ConstantArrayOrAggregateZero(API.LLVMConstArray(typ, Array(data), length(data)))
     end
 
     if VERSION >= v"1.1"
@@ -156,7 +164,6 @@ function Base.collect(ca::ConstantArray)
     return constants
 end
 
-
 # array interface
 Base.eltype(ca::ConstantArray) = eltype(llvmtype(ca))
 function Base.size(ca::ConstantArray)
@@ -195,20 +202,24 @@ end
 end
 identify(::Type{Value}, ::Val{API.LLVMConstantStructValueKind}) = ConstantStruct
 
+ConstantStructOrAggregateZero(value) = Value(value)::Union{ConstantStruct,ConstantAggregateZero}
+
 # anonymous
 ConstantStruct(values::Vector{<:Constant}; packed::Core.Bool=false) =
-    ConstantStruct(API.LLVMConstStruct(values, length(values), convert(Bool, packed)))
+    ConstantStructOrAggregateZero(API.LLVMConstStruct(values, length(values), convert(Bool, packed)))
 ConstantStruct(values::Vector{<:Constant}, ctx::Context; packed::Core.Bool=false) =
-    ConstantStruct(API.LLVMConstStructInContext(ctx, values, length(values), convert(Bool, packed)))
+    ConstantStructOrAggregateZero(API.LLVMConstStructInContext(ctx, values, length(values), convert(Bool, packed)))
 
 # named
 ConstantStruct(typ::StructType, values::Vector{<:Constant}) =
-    ConstantStruct(API.LLVMConstNamedStruct(typ, values, length(values)))
+    ConstantStructOrAggregateZero(API.LLVMConstNamedStruct(typ, values, length(values)))
 
 # create a ConstantStruct from a Julia object
 function ConstantStruct(value::T, ctx::Context=GlobalContext(); name=String(nameof(T)),
                         anonymous::Core.Bool=false, packed::Core.Bool=false) where {T}
     isbitstype(T) || throw(ArgumentError("Can only create a ConstantStruct from an isbits struct"))
+    isprimitivetype(T) && throw(ArgumentError("Cannot create a ConstantStruct from a primitive value"))
+
     constants = Vector{Constant}()
     for fieldname in fieldnames(T)
         field = getfield(value, fieldname)

test/core.jl

@@ -4,6 +4,9 @@ struct TestStruct
     z::Float16
 end
 
+struct TestSingleton
+end
+
 @testset "core" begin
 
 @testset "context" begin
@@ -418,6 +421,14 @@ Context() do ctx
         @test ca[1] == ConstantFP(vec[1], ctx)
         @test collect(ca) == ConstantFP.(vec, Ref(ctx))
     end
+    let
+        # tests for ConstantAggregateZero, constructed indirectly.
+        # should behave similarly to ConstantArray since it can get returned there.
+        ca = ConstantArray(Int[], ctx)
+        @test size(ca) == (0,)
+        @test length(ca) == 0
+        @test isempty(collect(ca))
+    end
 
     # multidimensional
     let
@@ -455,7 +466,7 @@ Context() do ctx
     end
     let
         test_struct = TestStruct(false, 52, -2.5)
-        constant_struct = ConstantStruct(test_struct, ctx; anonymous=false)
+        constant_struct = ConstantStruct(test_struct, ctx)
         constant_struct_type = llvmtype(constant_struct)
 
         @test constant_struct_type isa LLVM.StructType
@@ -467,7 +478,17 @@ Context() do ctx
         ]
         @test collect(operands(constant_struct)) == expected_operands
 
-        @test_throws ArgumentError ConstantStruct(test_struct, ctx; anonymous=false)
+        @test_throws ArgumentError ConstantStruct(test_struct, ctx)
+    end
+    let
+        test_struct = TestSingleton()
+        constant_struct = ConstantStruct(test_struct, ctx)
+        constant_struct_type = llvmtype(constant_struct)
+
+        @test isempty(operands(constant_struct))
+    end
+    let
+        @test_throws ArgumentError ConstantStruct(1, ctx)
     end
 
     end