Normalized TypeIds in type info reflection dump outputs, added assert tests for dynamic trait type info

Author: izagawd

library/coretests/tests/mem/type_info.rs

@@ -125,3 +125,252 @@ fn test_references() {
         _ => unreachable!(),
     }
 }
+
+#[test]
+fn test_dynamic_traits() {
+    use std::collections::HashSet;
+    use std::mem::type_info::Trait;
+    trait A<T> {}
+    trait B<T>: A<T> {}
+    trait C<T>: B<T> {}
+    trait D<T, U>: A<T> + B<T> + C<U> {}
+
+    trait E<const CONST_NUM: i32> {
+        type Foo;
+    }
+
+    trait AnotherTrait {}
+
+    trait BarTrait<'a, 'b, const N: usize>: AnotherTrait {}
+
+    trait FooTrait<'a, 'b, const N: usize>: BarTrait<'a, 'b, N> + for<'x> BarTrait<'x, 'x, 0> {}
+
+    trait ProjectorSuperSuperTrait<'a>: AnotherTrait {
+        type Item;
+        type AnotherItem;
+    }
+    trait ProjectorSuperTrait<'a, 'b>:
+        AnotherTrait + ProjectorSuperSuperTrait<'a, Item = &'a i32, AnotherItem = &'a i32>
+    {
+        type Item;
+        type AnotherItem;
+    }
+    trait ProjectorTrait<'a, 'b>:
+        ProjectorSuperTrait<'a, 'b, Item = &'a u32, AnotherItem = &'b u32>
+    {
+    }
+
+    fn preds_of<T: ?Sized + 'static>() -> &'static [Trait] {
+        match const { Type::of::<T>() }.kind {
+            TypeKind::DynTrait(d) => d.predicates,
+            _ => unreachable!(),
+        }
+    }
+
+    fn pred<'a>(preds: &'a [Trait], want: TypeId) -> &'a Trait {
+        preds
+            .iter()
+            .find(|p| p.ty == want)
+            .unwrap_or_else(|| panic!("missing predicate for {want:?}"))
+    }
+
+    fn assert_typeid_set_eq(actual: &[TypeId], expected: &[TypeId]) {
+        let actual_set: HashSet<TypeId> = actual.iter().copied().collect();
+        let expected_set: HashSet<TypeId> = expected.iter().copied().collect();
+        assert_eq!(actual.len(), actual_set.len(), "duplicates present: {actual:?}");
+        assert_eq!(
+            actual_set, expected_set,
+            "unexpected ids.\nactual: {actual:?}\nexpected: {expected:?}"
+        );
+    }
+
+    fn assert_predicates_exact(preds: &[Trait], expected_pred_ids: &[TypeId]) {
+        let actual_pred_ids: Vec<TypeId> = preds.iter().map(|p| p.ty).collect();
+        assert_typeid_set_eq(&actual_pred_ids, expected_pred_ids);
+    }
+
+    // dyn Send
+    {
+        let preds = preds_of::<dyn Send>();
+        assert_predicates_exact(preds, &[TypeId::of::<dyn Send>()]);
+
+        let p = pred(preds, TypeId::of::<dyn Send>());
+        assert!(p.is_auto);
+        assert!(p.super_traits.is_empty());
+    }
+
+    // dyn A<i32>
+    {
+        let preds = preds_of::<dyn A<i32>>();
+        assert_predicates_exact(preds, &[TypeId::of::<dyn A<i32>>()]);
+
+        let p = pred(preds, TypeId::of::<dyn A<i32>>());
+        assert!(!p.is_auto);
+        assert!(p.super_traits.is_empty());
+    }
+
+    // dyn B<i32> : A<i32>
+    {
+        let preds = preds_of::<dyn B<i32>>();
+        assert_predicates_exact(preds, &[TypeId::of::<dyn B<i32>>()]);
+
+        let p = pred(preds, TypeId::of::<dyn B<i32>>());
+        assert!(!p.is_auto);
+        assert_typeid_set_eq(p.super_traits, &[TypeId::of::<dyn A<i32>>()]);
+    }
+
+    // dyn C<i32> + Send : (C<i32> : B<i32> : A<i32>) + Send
+    {
+        let preds = preds_of::<dyn C<i32> + Send>();
+        assert_predicates_exact(preds, &[TypeId::of::<dyn C<i32>>(), TypeId::of::<dyn Send>()]);
+
+        let c = pred(preds, TypeId::of::<dyn C<i32>>());
+        assert!(!c.is_auto);
+        assert_typeid_set_eq(
+            c.super_traits,
+            &[TypeId::of::<dyn B<i32>>(), TypeId::of::<dyn A<i32>>()],
+        );
+
+        let send = pred(preds, TypeId::of::<dyn Send>());
+        assert!(send.is_auto);
+        assert!(send.super_traits.is_empty());
+    }
+
+    // dyn D<i32, bool> : A<i32> + B<i32> + C<bool> (and transitive super traits)
+    {
+        let preds = preds_of::<dyn D<i32, bool>>();
+        assert_predicates_exact(preds, &[TypeId::of::<dyn D<i32, bool>>()]);
+
+        let d = pred(preds, TypeId::of::<dyn D<i32, bool>>());
+        assert!(!d.is_auto);
+        assert_typeid_set_eq(
+            d.super_traits,
+            &[
+                TypeId::of::<dyn B<i32>>(),
+                TypeId::of::<dyn A<i32>>(),
+                TypeId::of::<dyn C<bool>>(),
+                TypeId::of::<dyn B<bool>>(),
+                TypeId::of::<dyn A<bool>>(),
+            ],
+        );
+    }
+
+    // dyn E<5, Foo = i32>
+    {
+        let preds = preds_of::<dyn E<5, Foo = i32>>();
+        assert_predicates_exact(preds, &[TypeId::of::<dyn E<5, Foo = i32>>()]);
+
+        let e = pred(preds, TypeId::of::<dyn E<5, Foo = i32>>());
+        assert!(!e.is_auto);
+        assert!(e.super_traits.is_empty());
+    }
+
+    // dyn for<'a> FooTrait<'a, 'a, 7>
+    {
+        let preds = preds_of::<dyn for<'a> FooTrait<'a, 'a, 7>>();
+        assert_predicates_exact(preds, &[TypeId::of::<dyn for<'a> FooTrait<'a, 'a, 7>>()]);
+
+        let foo = pred(preds, TypeId::of::<dyn for<'a> FooTrait<'a, 'a, 7>>());
+        assert!(!foo.is_auto);
+        assert_typeid_set_eq(
+            foo.super_traits,
+            &[
+                TypeId::of::<dyn for<'a> BarTrait<'a, 'a, 7>>(),
+                TypeId::of::<dyn for<'x> BarTrait<'x, 'x, 0>>(),
+                TypeId::of::<dyn AnotherTrait>(),
+            ],
+        );
+    }
+
+    // dyn FooTrait<'static, 'static, 7>
+    {
+        let preds = preds_of::<dyn FooTrait<'static, 'static, 7>>();
+        assert_predicates_exact(preds, &[TypeId::of::<dyn FooTrait<'static, 'static, 7>>()]);
+
+        let foo = pred(preds, TypeId::of::<dyn FooTrait<'static, 'static, 7>>());
+        assert!(!foo.is_auto);
+        assert_typeid_set_eq(
+            foo.super_traits,
+            &[
+                TypeId::of::<dyn BarTrait<'static, 'static, 7>>(),
+                TypeId::of::<dyn for<'x> BarTrait<'x, 'x, 0>>(),
+                TypeId::of::<dyn AnotherTrait>(),
+            ],
+        );
+    }
+
+    // dyn for<'a, 'b> FooTrait<'a, 'b, 7>
+    {
+        let preds = preds_of::<dyn for<'a, 'b> FooTrait<'a, 'b, 7>>();
+        assert_predicates_exact(preds, &[TypeId::of::<dyn for<'a, 'b> FooTrait<'a, 'b, 7>>()]);
+
+        let foo = pred(preds, TypeId::of::<dyn for<'a, 'b> FooTrait<'a, 'b, 7>>());
+        assert!(!foo.is_auto);
+        assert_typeid_set_eq(
+            foo.super_traits,
+            &[
+                TypeId::of::<dyn for<'a, 'b> BarTrait<'a, 'b, 7>>(),
+                TypeId::of::<dyn for<'x> BarTrait<'x, 'x, 0>>(),
+                TypeId::of::<dyn AnotherTrait>(),
+            ],
+        );
+    }
+
+    // dyn for<'a, 'b> ProjectorTrait<'a, 'b>
+    {
+        let preds = preds_of::<dyn for<'a, 'b> ProjectorTrait<'a, 'b>>();
+        assert_predicates_exact(preds, &[TypeId::of::<dyn for<'a, 'b> ProjectorTrait<'a, 'b>>()]);
+
+        let proj = pred(preds, TypeId::of::<dyn for<'a, 'b> ProjectorTrait<'a, 'b>>());
+        assert!(!proj.is_auto);
+        assert_typeid_set_eq(
+            proj.super_traits,
+            &[
+                TypeId::of::<
+                    dyn for<'a, 'b> ProjectorSuperTrait<
+                            'a,
+                            'b,
+                            Item = &'a u32,
+                            AnotherItem = &'b u32,
+                        >,
+                >(),
+                TypeId::of::<
+                    dyn for<'a> ProjectorSuperSuperTrait<'a, Item = &'a i32, AnotherItem = &'a i32>,
+                >(),
+                TypeId::of::<dyn AnotherTrait>(),
+            ],
+        );
+    }
+
+    // dyn for<'a> FooTrait<'a, 'a, 7> + Send + Sync
+    {
+        let preds = preds_of::<dyn for<'a> FooTrait<'a, 'a, 7> + Send + Sync>();
+        assert_predicates_exact(
+            preds,
+            &[
+                TypeId::of::<dyn for<'a> FooTrait<'a, 'a, 7>>(),
+                TypeId::of::<dyn Send>(),
+                TypeId::of::<dyn Sync>(),
+            ],
+        );
+
+        let foo = pred(preds, TypeId::of::<dyn for<'a> FooTrait<'a, 'a, 7>>());
+        assert!(!foo.is_auto);
+        assert_typeid_set_eq(
+            foo.super_traits,
+            &[
+                TypeId::of::<dyn for<'a> BarTrait<'a, 'a, 7>>(),
+                TypeId::of::<dyn for<'x> BarTrait<'x, 'x, 0>>(),
+                TypeId::of::<dyn AnotherTrait>(),
+            ],
+        );
+
+        let send = pred(preds, TypeId::of::<dyn Send>());
+        assert!(send.is_auto);
+        assert!(send.super_traits.is_empty());
+
+        let sync = pred(preds, TypeId::of::<dyn Sync>());
+        assert!(sync.is_auto);
+        assert!(sync.super_traits.is_empty());
+    }
+}