inference: implement type-based alias analysis to refine constrained field

[aviatesk]

This commit tries to propagate constraints imposed on object fields, e.g.:

struct SomeX{T}
    x::Union{Nothing,T}
end
mutable struct MutableSomeX{T}
    const x::Union{Nothing,T}
end

let # o1::SomeX{T}, o2::MutableSomeX{T}
    if !isnothing(o1.x)
        # now inference knows `o1.x::T` here
        ...
        if !isnothing(o2.x)
            # now inference knows `o2.x::T` here
            ...
        end
    end
end

The idea is that we can make isa and === propagate constraint
imposed on an object field if the identity of that object.
We can have such a lattice element that wraps return type of abstract
getfield call together with the object identity, and then we can
form a conditional constraint that propagates the refinement information
imposed on the object field when we see isa/=== applied the return
value of the preceding getfield call.

So this PR defines the new lattice element called MustAlias (and also
InterMustAlias, which just works in a similar way to InterConditional),
which may be formed upon getfield inference to hold the retrieved type
of the field and track the identity of the object (in inference,
"object identity" can be represented as a SlotNumber).
This PR also implements the new logic in abstract_call_builtin so that
isa and === can form a conditional constraint (i.e. Conditional)
from MustAlias-argument that may later refine the wrapped object to
PartialStruct that holds the refined field type information.

One important note here is, MustAlias expects the invariant that the
field of wrapped slot object never changes. The obvious limitation with
this invariant is that it can't propagate constraints imposed on mutable
fields, because inference currently doesn't have a precise (per-object)
knowledge of memory effect.

[aviatesk]

@femtomc you may also want to have a look at this, since I think this PR illustrates how tightly our abstract interpretation logic is bound to the lattice implementation, currently.

[aviatesk]

I may first work on an overhaul of our lattice implementation before going with this.

[jakobnissen]

Will this fix #39888 ?

[aviatesk]

It will, assuming Option is immutable.

[jakobnissen]

That's fantastic! ❤️ The failure propagate type info to duplicate field loads is indeed one of the main contributors for false positives in JET.
My guess would be that this inference improvement would only improve quality of the generated code a little bit, so it's not worth any significant compiler performance regressions to the average user.
Since it does generate slightly better code, perhaps it would make sense to enable it with -O3 - or does the -O3 flag only affect the backend LLVM compiler? In any case, it's probably not a big deal.

[aviatesk]

@nanosoldier runbenchmarks("inference", vs=":master")

[nanosoldier]

Your benchmark job has completed - possible performance regressions were detected. A full report can be found here.

[aviatesk]

@nanosoldier runbenchmarks("inference", vs=":master")

[nanosoldier]

Your benchmark job has completed - possible performance regressions were detected. A full report can be found here.

[aviatesk]

Yay! This PR introduces some complicated logic into inference, nevertheless it finally comes without any performance cost (actually it even makes it slightly faster)!

This should be ready to go, so I'm planning to merge this.

[vtjnash]

Do you want to do a joint-review tomorrow, or are you content with it as-is for merging?

[aviatesk]

Do you want to do a joint-review tomorrow, or are you content with it as-is for merging?

I'm almost certain that this can be merged as-is (since I confirmed e.g. this PR runs successfully if we enable MustAlias for the native compilation pipeline), while I'm happy to do a joint-review if you want to understand the details of this PR. The basic idea is to propagate MustAlias on getfield(x, :f) call and then form Conditional with PartialStruct when seeing isa/=== conditions on other getfield(x, :f) values.

[DilumAluthge]

Looks like this needs a manual (command-line) rebase.

[aviatesk]

@nanosoldier runbenchmarks("inference", vs=":master")

[nanosoldier]

Your benchmark job has completed - possible performance regressions were detected. A full report can be found here.

[aviatesk]

@nanosoldier runbenchmarks("inference", vs=":master")

[nanosoldier]

Your benchmark job has completed - possible performance regressions were detected. A full report can be found here.