Test concrete remote generic

Author: MrGVSV

crates/bevy_reflect/src/lib.rs

@@ -1343,31 +1343,38 @@ bevy_reflect::tests::should_reflect_debug::Test {
     fn should_reflect_nested_remote_type() {
         mod external_crate {
             pub struct TheirOuter<T> {
-                pub inner: TheirInner<T>,
+                pub a: TheirInner<T>,
+                pub b: TheirInner<bool>,
             }
             pub struct TheirInner<T>(pub T);
         }
 
         #[reflect_remote(external_crate::TheirOuter<T>, FromReflect)]
-        struct MyOuter<T: FromReflect> {
+        struct MyOuter<T: Reflect> {
             #[reflect(remote = "MyInner<T>")]
-            pub inner: external_crate::TheirInner<T>,
+            pub a: external_crate::TheirInner<T>,
+            #[reflect(remote = "MyInner<bool>")]
+            pub b: external_crate::TheirInner<bool>,
         }
 
         #[reflect_remote(external_crate::TheirInner<T>, FromReflect)]
-        struct MyInner<T: FromReflect>(pub T);
+        struct MyInner<T: Reflect>(pub T);
 
         let mut patch = DynamicStruct::default();
         patch.set_name("MyOuter".to_string());
-        patch.insert("inner", MyInner(external_crate::TheirInner(321)));
+        patch.insert("a", MyInner(external_crate::TheirInner(321)));
+        patch.insert("b", MyInner(external_crate::TheirInner(true)));
 
         let mut data = MyOuter(external_crate::TheirOuter {
-            inner: external_crate::TheirInner(123),
+            a: external_crate::TheirInner(123),
+            b: external_crate::TheirInner(false),
         });
 
-        assert_eq!(123, data.0.inner.0);
+        assert_eq!(123, data.0.a.0);
+        assert!(!data.0.b.0);
         data.apply(&patch);
-        assert_eq!(321, data.0.inner.0);
+        assert_eq!(321, data.0.a.0);
+        assert!(data.0.b.0);
     }
 
     #[test]

crates/bevy_reflect_compile_fail_tests/tests/reflect_remote/nested.fail.rs

@@ -45,4 +45,18 @@ mod mismatched_remote_type {
     struct MyInner<T: Reflect>(pub T);
 }
 
+mod mismatched_remote_generic {
+    use bevy_reflect::{reflect_remote, Reflect};
+
+    #[reflect_remote(super::external_crate::TheirOuter<T>, FromReflect)]
+    struct MyOuter<T: Reflect> {
+        // Reason: `TheirOuter::inner` is not defined as `TheirInner<bool>`
+        #[reflect(remote = "MyInner<bool>")]
+        pub inner: super::external_crate::TheirInner<bool>,
+    }
+
+    #[reflect_remote(super::external_crate::TheirInner<T>, FromReflect)]
+    struct MyInner<T: Reflect>(pub T);
+}
+
 fn main() {}

crates/bevy_reflect_compile_fail_tests/tests/reflect_remote/nested.fail.stderr

@@ -66,3 +66,16 @@ error[E0308]: mismatched types
    = note: expected struct `TheirInner<T>`
               found struct `TheirOuter<T>`
    = note: this error originates in the attribute macro `reflect_remote` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0308]: `?` operator has incompatible types
+  --> tests/reflect_remote/nested.fail.rs:51:5
+   |
+51 |     #[reflect_remote(super::external_crate::TheirOuter<T>, FromReflect)]
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected type parameter `T`, found `bool`
+52 |     struct MyOuter<T: Reflect> {
+   |                    - this type parameter
+   |
+   = note: `?` operator cannot convert from `TheirInner<bool>` to `TheirInner<T>`
+   = note: expected struct `TheirInner<T>`
+              found struct `TheirInner<bool>`
+   = note: this error originates in the attribute macro `reflect_remote` (in Nightly builds, run with -Z macro-backtrace for more info)