I'm not sure I understand the comment here, doesn't refining mean returning a PartialStruct? (though it makes sense to return nothing as a Union{} field type already implies undef[fldidx] === true)

This PR wasn't finished yesterday, so the logic might have been messed up. Undef the refined definition of PartialStruct, fields[fldidx] === Union{} is a special case, meaning that field is guaranteed not to be initialized, so we need to bail out here.

Renamed undef to undefs to avoid naming collision with the undef initializer.

I've inlined some logic implemented here because it is now only used once in other files.

NB: this method is not currently used from Compiler.jl. PR #57553 aims to fix that.

Just for my understanding, was there any situation that we couldn't represent with the old encoding?

The docs seem to suggest undefs[i] === true <-> fields[i] === Union{} but maybe there's a corner-case where that's not true?

undefs[i] === true -> fields[i] === Union{} is true, but the reverse isn't. Immutable structs with uninitialized pointer fields can have undefs[i] === true but at the same time fields[i] can be arbitrary types. We can probably make those fields[i] to Union{}, but I wanted to avoid encoding field defined-ness information into fields.

OK, that makes sense. Thanks for the details 👍

BTW, are you required to include anything that might come out of the type, or just what went into it? For example, if I make PartialStruct(Union{Foo,Bar}, undefs=[...], fields=[...]) where:

struct Foo
    a::Int
    b::Int
    Foo() = new()
end
struct Bar
    a::Any
    b::Any
    Bar() = new()
end

with rand(Bool) ? Foo() : Bar() (i.e. both fields undefined) - are the types in fields required to include Int, since that describes what we might read out of the isbits fields?

Or is it still correct to leave typ at Union{} in that case?

At least for now, PartialStruct cannot represent objects that are inferred as Union types. The expression (x::PartialStruct).typ is actually either a DataType or a UnionAll.

The UnionAll equivalent would be PartialStruct(Foo, ...) where:

struct Foo{T}
     a::T
     b::T
     Foo{T}() where T = new{T}()
 end

Foo{Int} is isbits and Foo{Any} is not

In such cases, PartialStruct won't be created.
More precisely, in compilers that don't use MustAlias, PartialStruct.typ::DataType is always true. I remember a compiler with MustAlias sometimes creates PartialStruct with UnionAll at some point, but I think that only happens within JET. It might be safer to restrict PartialStruct.typ to DataType for now.

The Oscar.jl tests seem to be running into this assertion now:

 From worker 4:	Internal error: during type inference of
      From worker 4:	(::Type{Oscar.IntersectionTheory.AbstractVarietyMap{V1, V2} where V2<:Oscar.IntersectionTheory.AbstractVarietyT where V1<:Oscar.IntersectionTheory.AbstractVarietyT})(Oscar.IntersectionTheory.AbstractVariety, Oscar.IntersectionTheory.AbstractVariety, Array{Oscar.MPolyQuoRingElem{Oscar.MPolyDecRingElem{Nemo.QQFieldElem, Nemo.QQMPolyRingElem}}, 1}, AbstractAlgebra.Generic.FunctionalMap{Oscar.MPolyQuoRing{Oscar.MPolyDecRingElem{Nemo.QQFieldElem, Nemo.QQMPolyRingElem}}, Oscar.MPolyDecRing{Nemo.QQFieldElem, Nemo.QQMPolyRing}})
      From worker 4:	Encountered unexpected error in runtime:
      From worker 4:	AssertionError(msg="`Union{}` typed field should be strictly undefined")
      From worker 4:	PartialStruct at ./coreir.jl:62

https://github.com/oscar-system/Oscar.jl/actions/runs/13611555768/job/38059503585#step:11:677