Type-object are immutable (essentially on Julia-level)

Almost, but not quite:

julia> struct T; x::Val{T.flags}; end

julia> T.flags
0x6a

julia> fieldtype(T, :x)
Val{0x62}

Don't know whether that is to worry about in practice, but it allows to produce the following inconsistency on this branch:

julia> f(::Type{T} where T) = Val{T.flags}
f (generic function with 1 method)

julia> struct T; x::f(T); end

julia> f(T)
Val{0x62}

julia> @code_typed f(T)
CodeInfo(
1 ─     return Val{0x6a}
) => Type{Val{0x6a}}

Can we restrict treating types as immutable to cases where a) we know not only it is a type, but which type and b) that type is fully constructed? Additionally, we'd want the result for a type that is still under construction not to be cached, as a future analysis might be less pessimistic. Can we do that?

If we decide correctness is edge cases like those is sufficiently important to to be more conservative about treating types as immutable, we could use the opportunity to also fix this case which we already have on master:

julia> f(::Type{T}) where T = isdefined(T, :instance)
f (generic function with 1 method)

julia> struct T; x::Val{f(T)}; end

julia> f(T)
false

julia> @code_typed f(T)
CodeInfo(
1 ─     return true
) => Bool

It is UB right now to call a function (in this case f) on a type during its declaration. We allow it, because we need to permit apply_type expressions with {}, but otherwise it should perhaps be more carefully restricted for user-sanity.

But as you note there, types have both #undef fields and non-constant fields (esp. layout and types)

There's also super:

julia> struct Foo <: (println(isdefined(Foo, :super)); Any) end
false

julia> isdefined(Foo, :super)
true

But AFAICT, all of these are set once during type construction and they don't change anymore.

It is UB right now to call a function (in this case f) on a type during its declaration.

But then this PR is valid as is? Or is a type actually changed somehow after its declaration is complete?

AFAIK currently, the PR assumption is not valid (#46328 (comment)), so currently we have specific lists of fields that are valid for these effects.

Do you have an example where undef-ness or mutability is observable which is not already UB?

Sorry I just mistakenly pushed unrelated changes into this branch and fixed it up. I will follow the discussion later.