fixed newtype_reflect macro + added full paths to types

fyrox-core/src/reflect/mod.rs

@@ -1464,77 +1464,104 @@ macro_rules! newtype_reflect {
             self.0.doc()
         }
 
-        fn fields_ref(&self, func: &mut dyn FnMut(&[FieldRef])) {
+        fn fields_ref(&self, func: &mut dyn FnMut(&[$crate::reflect::FieldRef])) {
             self.0.fields_ref(func)
         }
 
-        fn into_any(self: Box<Self>) -> Box<dyn Any> {
+        fn into_any(self: Box<Self>) -> Box<dyn std::any::Any> {
             self
         }
 
-        fn as_any(&self, func: &mut dyn FnMut(&dyn Any)) {
+        fn as_any(&self, func: &mut dyn FnMut(&dyn std::any::Any)) {
             self.0.as_any(func)
         }
 
-        fn as_any_mut(&mut self, func: &mut dyn FnMut(&mut dyn Any)) {
+        fn as_any_mut(&mut self, func: &mut dyn FnMut(&mut dyn std::any::Any)) {
             self.0.as_any_mut(func)
         }
 
-        fn as_reflect(&self, func: &mut dyn FnMut(&dyn Reflect)) {
+        fn as_reflect(&self, func: &mut dyn FnMut(&dyn $crate::reflect::Reflect)) {
             self.0.as_reflect(func)
         }
 
-        fn as_reflect_mut(&mut self, func: &mut dyn FnMut(&mut dyn Reflect)) {
+        fn as_reflect_mut(&mut self, func: &mut dyn FnMut(&mut dyn $crate::reflect::Reflect)) {
             self.0.as_reflect_mut(func)
         }
 
-        fn set(&mut self, value: Box<dyn Reflect>) -> Result<Box<dyn Reflect>, Box<dyn Reflect>> {
+        fn set(
+            &mut self,
+            value: Box<dyn $crate::reflect::Reflect>,
+        ) -> Result<Box<dyn $crate::reflect::Reflect>, Box<dyn $crate::reflect::Reflect>> {
             self.0.set(value)
         }
 
-        fn field(&self, name: &str, func: &mut dyn FnMut(Option<&dyn Reflect>)) {
+        fn field(&self, name: &str, func: &mut dyn FnMut(Option<&dyn $crate::reflect::Reflect>)) {
             self.0.field(name, func)
         }
 
-        fn field_mut(&mut self, name: &str, func: &mut dyn FnMut(Option<&mut dyn Reflect>)) {
+        fn field_mut(
+            &mut self,
+            name: &str,
+            func: &mut dyn FnMut(Option<&mut dyn $crate::reflect::Reflect>),
+        ) {
             self.0.field_mut(name, func)
         }
 
-        fn as_array(&self, func: &mut dyn FnMut(Option<&dyn ReflectArray>)) {
+        fn as_array(&self, func: &mut dyn FnMut(Option<&dyn $crate::reflect::ReflectArray>)) {
             self.0.as_array(func)
         }
 
-        fn as_array_mut(&mut self, func: &mut dyn FnMut(Option<&mut dyn ReflectArray>)) {
+        fn as_array_mut(
+            &mut self,
+            func: &mut dyn FnMut(Option<&mut dyn $crate::reflect::ReflectArray>),
+        ) {
             self.0.as_array_mut(func)
         }
 
-        fn as_list(&self, func: &mut dyn FnMut(Option<&dyn ReflectList>)) {
+        fn as_list(&self, func: &mut dyn FnMut(Option<&dyn $crate::reflect::ReflectList>)) {
             self.0.as_list(func)
         }
 
-        fn as_list_mut(&mut self, func: &mut dyn FnMut(Option<&mut dyn ReflectList>)) {
+        fn as_list_mut(
+            &mut self,
+            func: &mut dyn FnMut(Option<&mut dyn $crate::reflect::ReflectList>),
+        ) {
             self.0.as_list_mut(func)
         }
 
         fn as_inheritable_variable(
             &self,
-            func: &mut dyn FnMut(Option<&dyn ReflectInheritableVariable>),
+            func: &mut dyn FnMut(Option<&dyn $crate::reflect::ReflectInheritableVariable>),
         ) {
             self.0.as_inheritable_variable(func)
         }
 
         fn as_inheritable_variable_mut(
             &mut self,
-            func: &mut dyn FnMut(Option<&mut dyn ReflectInheritableVariable>),
+            func: &mut dyn FnMut(Option<&mut dyn $crate::reflect::ReflectInheritableVariable>),
         ) {
             self.0.as_inheritable_variable_mut(func)
         }
 
-        fn as_hash_map(&self, func: &mut dyn FnMut(Option<&dyn ReflectHashMap>)) {
+        fn as_handle(&self, func: &mut dyn FnMut(Option<&dyn $crate::reflect::ReflectHandle>)) {
+            self.0.as_handle(func)
+        }
+
+        fn as_handle_mut(
+            &mut self,
+            func: &mut dyn FnMut(Option<&mut dyn $crate::reflect::ReflectHandle>),
+        ) {
+            self.0.as_handle_mut(func)
+        }
+
+        fn as_hash_map(&self, func: &mut dyn FnMut(Option<&dyn $crate::reflect::ReflectHashMap>)) {
             self.0.as_hash_map(func)
         }
 
-        fn as_hash_map_mut(&mut self, func: &mut dyn FnMut(Option<&mut dyn ReflectHashMap>)) {
+        fn as_hash_map_mut(
+            &mut self,
+            func: &mut dyn FnMut(Option<&mut dyn $crate::reflect::ReflectHashMap>),
+        ) {
             self.0.as_hash_map_mut(func)
         }
     };