Fix searching for private members in the base types

Author: arimger

Assets/Editor Toolbox/Editor/Drawers/Helpers/Extraction/FieldValueExtractor.cs

@@ -11,7 +11,7 @@ public bool TryGetValue(string source, object declaringObject, out object value)
             }
 
             var type = declaringObject.GetType();
-            var info = type.GetField(source, ReflectionUtility.allBindings);
+            var info = ReflectionUtility.GetField(type, source);
             if (info == null)
             {
                 return false;

Assets/Editor Toolbox/Editor/Drawers/Helpers/Extraction/MethodValueExtractor.cs

@@ -1,7 +1,4 @@
-using System;
-using System.Reflection;
-
-namespace Toolbox.Editor.Drawers
+namespace Toolbox.Editor.Drawers
 {
     public class MethodValueExtractor : IValueExtractor
     {
@@ -14,7 +11,7 @@ public bool TryGetValue(string source, object declaringObject, out object value)
             }
 
             var type = declaringObject.GetType();
-            var info = type.GetMethod(source, ReflectionUtility.allBindings, null, CallingConventions.Any, new Type[0], null);
+            var info = ReflectionUtility.GetMethod(type, source);
             if (info == null)
             {
                 return false;

Assets/Editor Toolbox/Editor/Drawers/Helpers/Extraction/PropertyValueExtractor.cs

@@ -11,7 +11,7 @@ public bool TryGetValue(string source, object declaringObject, out object value)
             }
 
             var type = declaringObject.GetType();
-            var info = type.GetProperty(source, ReflectionUtility.allBindings);
+            var info = ReflectionUtility.GetProperty(type, source);
             if (info == null)
             {
                 return false;

Assets/Editor Toolbox/Editor/Drawers/Toolbox/Decorator/EditorButtonAttributeDrawer.cs

@@ -10,7 +10,7 @@ public class EditorButtonAttributeDrawer : ToolboxDecoratorDrawer<EditorButtonAt
     {
         private MethodInfo GetMethod(EditorButtonAttribute attribute, object[] targetObjects, string methodName)
         {
-            var methodInfo = ReflectionUtility.GetObjectMethod(methodName, targetObjects);
+            var methodInfo = ReflectionUtility.GetMethod(methodName, targetObjects);
             if (methodInfo == null)
             {
                 ToolboxEditorLog.AttributeUsageWarning(attribute, string.Format("{0} method not found.", methodName));

Assets/Editor Toolbox/Editor/Drawers/Toolbox/PropertyList/ReorderableListExposedAttributeDrawer.cs

@@ -56,7 +56,7 @@ private static MethodInfo FindMethod(SerializedObject target, string methodName,
                 return null;
             }
 
-            var methodInfo = ReflectionUtility.GetObjectMethod(methodName, target);
+            var methodInfo = ReflectionUtility.GetMethod(methodName, target);
             if (methodInfo == null)
             {
                 ToolboxEditorLog.AttributeUsageWarning(typeof(ReorderableListExposedAttribute), string.Format("{0} method not found.", methodName));

Assets/Editor Toolbox/Editor/Utilities/ReflectionUtility.cs

@@ -13,6 +13,33 @@ internal static class ReflectionUtility
         public const BindingFlags allBindings = BindingFlags.Instance |
             BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public;
 
+        internal static FieldInfo GetField(Type targetType, string fieldName)
+        {
+            return GetField(targetType, fieldName, allBindings);
+        }
+
+        internal static FieldInfo GetField(Type targetType, string fieldName, BindingFlags bindingFlags)
+        {
+            var field = targetType.GetField(fieldName, bindingFlags);
+            if (field == null && bindingFlags.HasFlag(BindingFlags.NonPublic))
+            {
+                //NOTE: if a method is not found and we searching for a private method we should look into parent classes
+                Type baseType = targetType.BaseType;
+                while (baseType != null)
+                {
+                    field = baseType.GetField(fieldName, bindingFlags);
+                    if (field != null)
+                    {
+                        break;
+                    }
+
+                    baseType = baseType.BaseType;
+                }
+            }
+
+            return field;
+        }
+
         /// <summary>
         /// Returns <see cref="MethodInfo"/> of the searched method within the Editor <see cref="Assembly"/>.
         /// </summary>
@@ -21,32 +48,42 @@ internal static MethodInfo GetEditorMethod(string classType, string methodName,
             return editorAssembly.GetType(classType).GetMethod(methodName, falgs);
         }
 
-        internal static MethodInfo GetObjectMethod(string methodName, SerializedObject serializedObject)
+        internal static MethodInfo GetMethod(string methodName, SerializedObject serializedObject)
         {
-            return GetObjectMethod(methodName, serializedObject.targetObjects);
+            return GetMethod(methodName, serializedObject.targetObjects);
         }
 
-        internal static MethodInfo GetObjectMethod(string methodName, params object[] targetObjects)
+        internal static MethodInfo GetMethod(string methodName, params object[] targetObjects)
         {
-            return GetObjectMethod(methodName, allBindings, targetObjects);
+            return GetMethod(methodName, allBindings, targetObjects);
         }
 
-        internal static MethodInfo GetObjectMethod(string methodName, BindingFlags bindingFlags, params object[] targetObjects)
+        internal static MethodInfo GetMethod(string methodName, BindingFlags bindingFlags, params object[] targetObjects)
         {
             if (targetObjects == null || targetObjects.Length == 0)
             {
                 return null;
             }
 
             var targetType = targetObjects[0].GetType();
-            var methodInfo = GetObjectMethod(targetType, methodName, bindingFlags);
+            return GetMethod(targetType, methodName, bindingFlags);
+        }
+
+        internal static MethodInfo GetMethod(Type targetType, string methodName)
+        {
+            return GetMethod(targetType, methodName, allBindings);
+        }
+
+        internal static MethodInfo GetMethod(Type targetType, string methodName, BindingFlags bindingFlags)
+        {
+            var methodInfo = targetType.GetMethod(methodName, bindingFlags, null, CallingConventions.Any, new Type[0], null);
             if (methodInfo == null && bindingFlags.HasFlag(BindingFlags.NonPublic))
             {
                 //NOTE: if a method is not found and we searching for a private method we should look into parent classes
                 var baseType = targetType.BaseType;
                 while (baseType != null)
                 {
-                    methodInfo = GetObjectMethod(baseType, methodName, bindingFlags);
+                    methodInfo = baseType.GetMethod(methodName, bindingFlags, null, CallingConventions.Any, new Type[0], null);
                     if (methodInfo != null)
                     {
                         break;
@@ -59,9 +96,31 @@ internal static MethodInfo GetObjectMethod(string methodName, BindingFlags bindi
             return methodInfo;
         }
 
-        internal static MethodInfo GetObjectMethod(Type targetType, string methodName, BindingFlags bindingFlags)
+        internal static PropertyInfo GetProperty(Type targetType, string propertyName)
+        {
+            return GetProperty(targetType, propertyName, allBindings);
+        }
+
+        internal static PropertyInfo GetProperty(Type targetType, string propertyName, BindingFlags bindingFlags)
         {
-            return targetType.GetMethod(methodName, bindingFlags, null, CallingConventions.Any, new Type[0], null);
+            var property = targetType.GetProperty(propertyName, bindingFlags);
+            if (property == null && bindingFlags.HasFlag(BindingFlags.NonPublic))
+            {
+                //NOTE: if a method is not found and we searching for a private method we should look into parent classes
+                Type baseType = targetType.BaseType;
+                while (baseType != null)
+                {
+                    property = baseType.GetProperty(propertyName, bindingFlags);
+                    if (property != null)
+                    {
+                        break;
+                    }
+
+                    baseType = baseType.BaseType;
+                }
+            }
+
+            return property;
         }
 
         /// <summary>
@@ -70,7 +129,7 @@ internal static MethodInfo GetObjectMethod(Type targetType, string methodName, B
         internal static bool TryInvokeMethod(string methodName, SerializedObject serializedObject)
         {
             var targetObjects = serializedObject.targetObjects;
-            var method = GetObjectMethod(methodName, targetObjects);
+            var method = GetMethod(methodName, targetObjects);
             if (method == null)
             {
                 return false;