bevy_reflect: Reflect remote types

crates/bevy_reflect/compile_fail/Cargo.toml

@@ -20,3 +20,7 @@ harness = false
 [[test]]
 name = "func"
 harness = false
+
+[[test]]
+name = "remote"
+harness = false

crates/bevy_reflect/compile_fail/tests/reflect_remote/incorrect_wrapper_fail.rs

@@ -0,0 +1,24 @@
+use bevy_reflect::Reflect;
+
+mod external_crate {
+    pub struct TheirFoo {
+        pub value: u32,
+    }
+}
+
+#[repr(transparent)]
+#[derive(Reflect)]
+#[reflect(from_reflect = false)]
+struct MyFoo(#[reflect(ignore)] pub external_crate::TheirFoo);
+
+#[derive(Reflect)]
+//~^ ERROR: the trait bound `MyFoo: ReflectRemote` is not satisfied
+#[reflect(from_reflect = false)]
+struct MyStruct {
+    // Reason: `MyFoo` does not implement `ReflectRemote` (from `#[reflect_remote]` attribute)
+    #[reflect(remote = MyFoo)]
+    //~^ ERROR: the trait bound `MyFoo: ReflectRemote` is not satisfied
+    foo: external_crate::TheirFoo,
+}
+
+fn main() {}

crates/bevy_reflect/compile_fail/tests/reflect_remote/incorrect_wrapper_pass.rs

@@ -0,0 +1,21 @@
+//@check-pass
+use bevy_reflect::{reflect_remote, Reflect};
+
+mod external_crate {
+    pub struct TheirFoo {
+        pub value: u32,
+    }
+}
+
+#[reflect_remote(external_crate::TheirFoo)]
+struct MyFoo {
+    pub value: u32,
+}
+
+#[derive(Reflect)]
+struct MyStruct {
+    #[reflect(remote = MyFoo)]
+    foo: external_crate::TheirFoo,
+}
+
+fn main() {}

crates/bevy_reflect/compile_fail/tests/reflect_remote/invalid_definition_fail.rs

@@ -0,0 +1,63 @@
+mod structs {
+    use bevy_reflect::reflect_remote;
+
+    mod external_crate {
+        pub struct TheirStruct {
+            pub value: u32,
+        }
+    }
+
+    #[reflect_remote(external_crate::TheirStruct)]
+    //~^ ERROR: `?` operator has incompatible types
+    struct MyStruct {
+        // Reason: Should be `u32`
+        pub value: bool,
+        //~^ ERROR: mismatched types
+    }
+}
+
+mod tuple_structs {
+    use bevy_reflect::reflect_remote;
+
+    mod external_crate {
+        pub struct TheirStruct(pub u32);
+    }
+
+    #[reflect_remote(external_crate::TheirStruct)]
+    //~^ ERROR: `?` operator has incompatible types
+    struct MyStruct(
+        // Reason: Should be `u32`
+        pub bool,
+        //~^ ERROR: mismatched types
+    );
+}
+
+mod enums {
+    use bevy_reflect::reflect_remote;
+
+    mod external_crate {
+        pub enum TheirStruct {
+            Unit,
+            Tuple(u32),
+            Struct { value: usize },
+        }
+    }
+
+    #[reflect_remote(external_crate::TheirStruct)]
+    //~^ ERROR: variant `enums::external_crate::TheirStruct::Unit` does not have a field named `0`
+    //~| ERROR: variant `enums::external_crate::TheirStruct::Unit` has no field named `0`
+    //~| ERROR: `?` operator has incompatible types
+    //~| ERROR: `?` operator has incompatible types
+    enum MyStruct {
+        // Reason: Should be unit variant
+        Unit(i32),
+        // Reason: Should be `u32`
+        Tuple(bool),
+        //~^ ERROR: mismatched types
+        // Reason: Should be `usize`
+        Struct { value: String },
+        //~^ ERROR: mismatched types
+    }
+}
+
+fn main() {}

crates/bevy_reflect/compile_fail/tests/reflect_remote/invalid_definition_pass.rs

@@ -0,0 +1,48 @@
+//@check-pass
+
+mod structs {
+    use bevy_reflect::reflect_remote;
+
+    mod external_crate {
+        pub struct TheirStruct {
+            pub value: u32,
+        }
+    }
+
+    #[reflect_remote(external_crate::TheirStruct)]
+    struct MyStruct {
+        pub value: u32,
+    }
+}
+
+mod tuple_structs {
+    use bevy_reflect::reflect_remote;
+
+    mod external_crate {
+        pub struct TheirStruct(pub u32);
+    }
+
+    #[reflect_remote(external_crate::TheirStruct)]
+    struct MyStruct(pub u32);
+}
+
+mod enums {
+    use bevy_reflect::reflect_remote;
+
+    mod external_crate {
+        pub enum TheirStruct {
+            Unit,
+            Tuple(u32),
+            Struct { value: usize },
+        }
+    }
+
+    #[reflect_remote(external_crate::TheirStruct)]
+    enum MyStruct {
+        Unit,
+        Tuple(u32),
+        Struct { value: usize },
+    }
+}
+
+fn main() {}

crates/bevy_reflect/compile_fail/tests/reflect_remote/macro_order_fail.rs

@@ -0,0 +1,19 @@
+use bevy_reflect::{reflect_remote, std_traits::ReflectDefault};
+
+mod external_crate {
+    #[derive(Debug, Default)]
+    pub struct TheirType {
+        pub value: String,
+    }
+}
+
+#[derive(Debug, Default)]
+#[reflect_remote(external_crate::TheirType)]
+#[reflect(Debug, Default)]
+struct MyType {
+    pub value: String,
+    //~^ ERROR: no field `value` on type `&MyType`
+    //~| ERROR: struct `MyType` has no field named `value`
+}
+
+fn main() {}

crates/bevy_reflect/compile_fail/tests/reflect_remote/macro_order_pass.rs

@@ -0,0 +1,18 @@
+//@check-pass
+use bevy_reflect::{reflect_remote, std_traits::ReflectDefault};
+
+mod external_crate {
+    #[derive(Debug, Default)]
+    pub struct TheirType {
+        pub value: String,
+    }
+}
+
+#[reflect_remote(external_crate::TheirType)]
+#[derive(Debug, Default)]
+#[reflect(Debug, Default)]
+struct MyType {
+    pub value: String,
+}
+
+fn main() {}

crates/bevy_reflect/compile_fail/tests/reflect_remote/nested_fail.rs

@@ -0,0 +1,75 @@
+mod external_crate {
+    pub struct TheirOuter<T> {
+        pub inner: TheirInner<T>,
+    }
+    pub struct TheirInner<T>(pub T);
+}
+
+mod missing_attribute {
+    use bevy_reflect::{FromReflect, GetTypeRegistration, reflect_remote};
+
+    #[reflect_remote(super::external_crate::TheirOuter<T>)]
+    struct MyOuter<T: FromReflect + GetTypeRegistration> {
+        // Reason: Missing `#[reflect(remote = ...)]` attribute
+        pub inner: super::external_crate::TheirInner<T>,
+    }
+
+    #[reflect_remote(super::external_crate::TheirInner<T>)]
+    struct MyInner<T>(pub T);
+}
+
+mod incorrect_inner_type {
+    use bevy_reflect::{FromReflect, GetTypeRegistration, reflect_remote};
+
+    #[reflect_remote(super::external_crate::TheirOuter<T>)]
+    //~^ ERROR: `TheirInner<T>` does not implement `PartialReflect` so cannot be introspected
+    //~| ERROR: `TheirInner<T>` does not implement `PartialReflect` so cannot be introspected
+    //~| ERROR: `TheirInner<T>` does not implement `PartialReflect` so cannot be introspected
+    //~| ERROR: `TheirInner<T>` can not be used as a dynamic type path
+    //~| ERROR: `?` operator has incompatible types
+    struct MyOuter<T: FromReflect + GetTypeRegistration> {
+        // Reason: Should not use `MyInner<T>` directly
+        pub inner: MyInner<T>,
+        //~^ ERROR: mismatched types
+    }
+
+    #[reflect_remote(super::external_crate::TheirInner<T>)]
+    struct MyInner<T>(pub T);
+}
+
+mod mismatched_remote_type {
+    use bevy_reflect::{FromReflect, GetTypeRegistration, reflect_remote};
+
+    #[reflect_remote(super::external_crate::TheirOuter<T>)]
+    //~^ ERROR: mismatched types
+    //~| ERROR: mismatched types
+    struct MyOuter<T: FromReflect + GetTypeRegistration> {
+        // Reason: Should be `MyInner<T>`
+        #[reflect(remote = MyOuter<T>)]
+        //~^ ERROR: mismatched types
+        pub inner: super::external_crate::TheirInner<T>,
+    }
+
+    #[reflect_remote(super::external_crate::TheirInner<T>)]
+    struct MyInner<T>(pub T);
+}
+
+mod mismatched_remote_generic {
+    use bevy_reflect::{FromReflect, GetTypeRegistration, reflect_remote};
+
+    #[reflect_remote(super::external_crate::TheirOuter<T>)]
+    //~^ ERROR: `?` operator has incompatible types
+    //~| ERROR: mismatched types
+    //~| ERROR: mismatched types
+    struct MyOuter<T: FromReflect + GetTypeRegistration> {
+        // Reason: `TheirOuter::inner` is not defined as `TheirInner<bool>`
+        #[reflect(remote = MyInner<bool>)]
+        pub inner: super::external_crate::TheirInner<bool>,
+        //~^ ERROR: mismatched types
+    }
+
+    #[reflect_remote(super::external_crate::TheirInner<T>)]
+    struct MyInner<T>(pub T);
+}
+
+fn main() {}

crates/bevy_reflect/compile_fail/tests/reflect_remote/nested_pass.rs

@@ -0,0 +1,20 @@
+//@check-pass
+use bevy_reflect::{FromReflect, GetTypeRegistration, reflect_remote, Reflect, Typed};
+
+mod external_crate {
+    pub struct TheirOuter<T> {
+        pub inner: TheirInner<T>,
+    }
+    pub struct TheirInner<T>(pub T);
+}
+
+#[reflect_remote(external_crate::TheirOuter<T>)]
+struct MyOuter<T: FromReflect + Typed + GetTypeRegistration> {
+    #[reflect(remote = MyInner<T>)]
+    pub inner: external_crate::TheirInner<T>,
+}
+
+#[reflect_remote(external_crate::TheirInner<T>)]
+struct MyInner<T: Reflect>(pub T);
+
+fn main() {}