Support ADT types in type info reflection

[SpriteOvO]

Tracking issue: #146922 #![feature(type_info)]

This PR supports ADT types for feature type_info reflection.
(It's still a draft PR, with implementation in progress)

Note that this PR does not take SemVer into consideration (I left a FIXME comment). As discussed earlier (comment), this requires further discussion. However, I hope we could get an initial implementation to land first, so we can start playing with it.

Progress / Checklist

• Struct support.
• Enum
• Union
• Generics
• Methods Implemented and to be implemented in other PRs
• Traits Implemented and to be implemented in other PRs
• Rebasing PR to main branch
  (It's currently based on PR Support primitives in type info reflection #151123, so here's an extra commit)
• Cleanup and Rebase.
• Fix field info for references. (see comment)

r? @oli-obk

[rustbot]

oli-obk is not on the review rotation at the moment.
They may take a while to respond.

[SpriteOvO]

I feel like I should write sym::Some discriminant for name? 🤔 Writing ptr directly seems to work, but this relies on how Option<&'static str> is underlyingly represented IIUC.

But const eval interpreter doesn't complain about this -- perhaps it should?

[oli-obk]

the interpreter doesn't care if the value is exactly the same as if it had its discriminant written. There is some talk about SetDiscriminant needing to happen always, but it's not really important for us here, this will be fixed by whoever changes it

also irrelevant if we make the field just always have a name (rendering the index)

[oli-obk]

the interpreter doesn't care if the value is exactly the same as if it had its discriminant written. There is some talk about SetDiscriminant needing to happen always, but it's not really important for us here, this will be fixed by whoever changes it

also irrelevant if we make the field just always have a name (rendering the index)

[9SonSteroids]

Is there anything missing from this PR / is there some way I could help? @SpriteOvO

[SpriteOvO]

I've almost finished it locally, but there's still some cleanup and rebasing I need to do before it's ready for review. Just been a bit busy lately.

[9SonSteroids]

@SpriteOvO Btw traits are already done in the other PR and unions / methods seem out of scope of ADTs so consider omiting them from this PR

[SpriteOvO]

This is wrong. I'll look into it tomorrow.

The other parts is ready for review.

[SpriteOvO]

Okay, so the offset == 0 is correct, since the fields are reordered for layout optimization.

It's still weird that the TypeId of &'static u16 are not equal. I made a debugging example:

let at_const_block = const {
    struct TestStruct {
        first: u8,
        second: u16,
        reference: &'static u16,
    }

    let Type { kind: Struct(ty), size, .. } = Type::of::<TestStruct>() else { panic!() };
    assert!(size == Some(size_of::<TestStruct>()));
    assert!(!ty.non_exhaustive);
    assert!(ty.fields.len() == 3);
    assert!(ty.fields[0].name == "first");
    assert!(ty.fields[0].ty == TypeId::of::<u8>());
    assert!(ty.fields[0].offset == offset_of!(TestStruct, first));
    assert!(ty.fields[1].name == "second");
    assert!(ty.fields[1].ty == TypeId::of::<u16>());
    assert!(ty.fields[1].offset == offset_of!(TestStruct, second));
    assert!(ty.fields[2].name == "reference");
    assert!(ty.fields[2].ty != TypeId::of::<&'static u16>()); // FIXME(type_info): should be ==
    assert!(ty.fields[2].offset == offset_of!(TestStruct, reference));
    (ty.fields[2].ty, TypeId::of::<&'static u16>())
};
let at_runtime = TypeId::of::<&'static u16>();
eprintln!("runtime: {at_runtime:?}");
eprintln!("const: {at_const_block:?}");
assert_eq!(at_runtime, at_const_block.0);
assert_eq!(at_runtime, at_const_block.1);

All assertions in this example are succeeded, no assertion failed, for both runtime and compile-time. Outputs:

runtime: TypeId(0x9e1edc294606897cc59b170c3a16c732)
const: (TypeId(0x9e1edc294606897cc59b170c3a16c732), TypeId(0x9e1edc294606897cc59b170c3a16c732))

I also add a debugging print to compiler when writing the type ID for fields, outputs:

u8 = 596b48cc04376e64d5c788c2aa46bdb
u16 = c50c4a8d8e150aa67101203f1fab1cd7
&'static u16 = 9e1edc294606897cc59b170c3a16c732

All outputs of &'static u16 type ID are the same, but the assertion ty.fields[2].ty != TypeId::of::<&'static u16>() passed in const block. I'm confused about what happened.

Any idea?

[SpriteOvO]

More minimal:

struct TestStruct {
    reference: &'static u16,
}

let ret = const {
    let Type { kind: Struct(ty), .. } = Type::of::<TestStruct>() else { panic!() };
    let ret = (ty.fields[0].ty, TypeId::of::<&'static u16>());
    assert!(ret.0 != ret.1); // FIXME(type_info): should be ==
    ret
};

assert_eq!(ret.0, ret.1);

[rustbot]

Some changes occurred to the CTFE machinery

cc @RalfJung, @oli-obk, @lcnr

The reflection data structures are tied exactly to the implementation
in the compiler. Make sure to also adjust rustc_const_eval/src/const_eval/type_info.rs

cc @oli-obk