CallstackFilterTool.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Text.RegularExpressions;
using UnityEditor;
using UnityEngine;

namespace CallstackFilter
{
    [Serializable]
    internal class CallstackFilterEntry
    {
        public string typeName;
        public string methodName;
        public bool filterAllMembers;
        public bool enabled = true;
    }

    [Serializable]
    internal class CallstackFilterConfig
    {
        public List<CallstackFilterEntry> entries = new List<CallstackFilterEntry>();
    }

    [InitializeOnLoad]
    internal static class CallstackFilterRuntime
    {
        static readonly Type s_ConsoleWindowType =
            typeof(EditorWindow).Assembly.GetType("UnityEditor.ConsoleWindow");

        static readonly FieldInfo s_MethodsField = s_ConsoleWindowType?.GetField(
            "s_MethodsToHideInCallstack", BindingFlags.Static | BindingFlags.NonPublic);

        static readonly FieldInfo s_RegexField = s_ConsoleWindowType?.GetField(
            "s_GenericMethodSignatureRegex", BindingFlags.Static | BindingFlags.NonPublic);

        static string ConfigPath => Path.Combine(Application.dataPath, "..", "ProjectSettings", "CallstackFilters.json");

        static CallstackFilterConfig s_Config;
        static List<MethodInfo> s_LastKnownMethods;

        static CallstackFilterRuntime()
        {
            EditorApplication.delayCall += ApplyFilters;
            EditorApplication.update += OnUpdate;
        }

        static void OnUpdate()
        {
            if (s_ConsoleWindowType == null || s_MethodsField == null)
                return;

            var current = s_MethodsField.GetValue(null) as List<MethodInfo>;
            if (current != s_LastKnownMethods)
                ApplyFilters();
        }

        internal static CallstackFilterConfig GetConfig()
        {
            if (s_Config == null)
                s_Config = LoadConfig();
            return s_Config;
        }

        internal static void SaveAndApply()
        {
            SaveConfig(s_Config);
            ApplyFilters();
        }

        static CallstackFilterConfig LoadConfig()
        {
            try
            {
                if (File.Exists(ConfigPath))
                    return JsonUtility.FromJson<CallstackFilterConfig>(File.ReadAllText(ConfigPath))
                           ?? new CallstackFilterConfig();
            }
            catch (Exception e)
            {
                Debug.LogError($"[CallstackFilter] Failed to load config: {e.Message}");
            }
            return new CallstackFilterConfig();
        }

        static void SaveConfig(CallstackFilterConfig config)
        {
            try
            {
                File.WriteAllText(ConfigPath, JsonUtility.ToJson(config, true));
            }
            catch (Exception e)
            {
                Debug.LogError($"[CallstackFilter] Failed to save config: {e.Message}");
            }
        }

        static void ApplyFilters()
        {
            if (s_ConsoleWindowType == null || s_MethodsField == null || s_RegexField == null)
                return;

            var config = GetConfig();
            if (config.entries.Count == 0) return;

            var methods = s_MethodsField.GetValue(null) as List<MethodInfo>;
            var regexDict = s_RegexField.GetValue(null) as Dictionary<MethodInfo, Regex>;

            if (methods == null)
            {
                methods = new List<MethodInfo>();
                s_MethodsField.SetValue(null, methods);
            }

            if (regexDict == null)
            {
                regexDict = new Dictionary<MethodInfo, Regex>();
                s_RegexField.SetValue(null, regexDict);
            }

            foreach (var entry in config.entries)
            {
                if (!entry.enabled || string.IsNullOrEmpty(entry.typeName))
                    continue;

                if (!entry.filterAllMembers && string.IsNullOrEmpty(entry.methodName))
                    continue;

                var resolved = entry.filterAllMembers
                    ? ResolveAllMethods(entry.typeName)
                    : ResolveMethodInfos(entry.typeName, entry.methodName);
                if (resolved == null) continue;

                foreach (var method in resolved)
                {
                    if (methods.Contains(method))
                        continue;

                    methods.Add(method);

                    if (method.IsGenericMethod)
                    {
                        var regex = BuildGenericRegex(method);
                        if (regex != null)
                            regexDict.TryAdd(method, regex);
                    }
                }
            }

            s_LastKnownMethods = methods;
        }

        static Type FindType(string typeName)
        {
            foreach (var asm in AppDomain.CurrentDomain.GetAssemblies())
            {
                var type = asm.GetType(typeName, false);
                if (type != null) return type;
            }
            return null;
        }

        static MethodInfo[] ResolveAllMethods(string typeName)
        {
            var targetType = FindType(typeName);
            if (targetType == null) return null;

            return targetType.GetMethods(
                    BindingFlags.Public | BindingFlags.NonPublic |
                    BindingFlags.Static | BindingFlags.Instance |
                    BindingFlags.DeclaredOnly)
                .ToArray();
        }

        static MethodInfo[] ResolveMethodInfos(string typeName, string methodName)
        {
            var targetType = FindType(typeName);
            if (targetType == null) return null;

            return targetType.GetMethods(
                    BindingFlags.Public | BindingFlags.NonPublic |
                    BindingFlags.Static | BindingFlags.Instance |
                    BindingFlags.DeclaredOnly)
                .Where(m => m.Name == methodName)
                .ToArray();
        }

        internal static string ValidateEntry(string typeName, string methodName, bool filterAll)
        {
            var targetType = FindType(typeName);
            if (targetType == null)
                return $"Type '{typeName}' not found in any loaded assembly.";

            if (filterAll)
            {
                var all = targetType.GetMethods(
                    BindingFlags.Public | BindingFlags.NonPublic |
                    BindingFlags.Static | BindingFlags.Instance |
                    BindingFlags.DeclaredOnly);
                if (all.Length == 0)
                    return $"Type '{typeName}' has no methods.";
                return null;
            }

            var methods = targetType.GetMethods(
                    BindingFlags.Public | BindingFlags.NonPublic |
                    BindingFlags.Static | BindingFlags.Instance |
                    BindingFlags.DeclaredOnly)
                .Where(m => m.Name == methodName)
                .ToArray();

            if (methods.Length == 0)
                return $"Method '{methodName}' not found on type '{typeName}'.";

            return null;
        }

        static Regex BuildGenericRegex(MethodInfo method)
        {
            var classType = method.DeclaringType;
            if (classType == null) return null;

            var ns = classType.Namespace;
            var escapedNs = string.IsNullOrEmpty(ns) ? "" : Regex.Escape(ns) + @"\.";
            var escapedClassName = Regex.Escape(classType.Name);
            var escapedMethodName = Regex.Escape(method.Name);
            var pattern = escapedNs + escapedClassName + @"(?:\[.*?\])?\:(" +
                          escapedMethodName + @")([^\(]*)\s*\(([^\)]*)\)";
            return new Regex(pattern, RegexOptions.Compiled);
        }
    }

    internal class CallstackFilterSettingsProvider : SettingsProvider
    {
        string m_NewTypeName = "";
        string m_NewMethodName = "";
        bool m_NewFilterAll;
        Vector2 m_ScrollPos;

        CallstackFilterSettingsProvider()
            : base("Preferences/Callstack Filter", SettingsScope.User) { }

        [SettingsProvider]
        static SettingsProvider Create() => new CallstackFilterSettingsProvider();

        public override void OnGUI(string searchContext)
        {
            var config = CallstackFilterRuntime.GetConfig();

            EditorGUILayout.Space();
            EditorGUILayout.LabelField("Custom Callstack Filters", EditorStyles.boldLabel);
            EditorGUILayout.HelpBox(
                "Methods added here will be hidden from Console callstacks.\n" +
                "Requires Console > Strip Logging Callstack to be enabled.\n" +
                "Persisted in ProjectSettings/CallstackFilters.json.",
                MessageType.Info);

            EditorGUILayout.Space();

            // --- Existing entries ---
            m_ScrollPos = EditorGUILayout.BeginScrollView(m_ScrollPos);

            int removeIndex = -1;
            bool changed = false;
            for (int i = 0; i < config.entries.Count; i++)
            {
                var entry = config.entries[i];
                EditorGUILayout.BeginHorizontal();

                var newEnabled = EditorGUILayout.Toggle(entry.enabled, GUILayout.Width(20));
                if (newEnabled != entry.enabled)
                {
                    entry.enabled = newEnabled;
                    changed = true;
                }

                EditorGUILayout.LabelField(entry.typeName, GUILayout.MinWidth(200));
                EditorGUILayout.LabelField(entry.filterAllMembers ? "*" : entry.methodName, GUILayout.MinWidth(100));

                if (GUILayout.Button("X", GUILayout.Width(24)))
                    removeIndex = i;

                EditorGUILayout.EndHorizontal();
            }

            EditorGUILayout.EndScrollView();

            if (removeIndex >= 0)
            {
                config.entries.RemoveAt(removeIndex);
                changed = true;
            }

            // --- Add new entry ---
            EditorGUILayout.Space();
            EditorGUILayout.LabelField("Add New Filter", EditorStyles.boldLabel);

            m_NewTypeName = EditorGUILayout.TextField("Full Type Name", m_NewTypeName);
            m_NewFilterAll = EditorGUILayout.Toggle("Filter All Members", m_NewFilterAll);
            using (new EditorGUI.DisabledScope(m_NewFilterAll))
                m_NewMethodName = EditorGUILayout.TextField("Method Name", m_NewFilterAll ? "" : m_NewMethodName);

            EditorGUILayout.BeginHorizontal();
            if (GUILayout.Button("Add", GUILayout.Height(24)))
            {
                var typeName = m_NewTypeName?.Trim();
                var methodName = m_NewFilterAll ? "*" : m_NewMethodName?.Trim();
                if (string.IsNullOrEmpty(typeName) || (!m_NewFilterAll && string.IsNullOrEmpty(methodName)))
                {
                    EditorUtility.DisplayDialog("Error", "Type name and method name cannot be empty.", "OK");
                }
                else
                {
                    var error = CallstackFilterRuntime.ValidateEntry(typeName, m_NewFilterAll ? null : methodName, m_NewFilterAll);
                    if (error != null)
                    {
                        EditorUtility.DisplayDialog("Validation Failed", error, "OK");
                    }
                    else
                    {
                        bool duplicate = config.entries.Any(e =>
                            e.typeName == typeName && e.filterAllMembers == m_NewFilterAll
                            && (m_NewFilterAll || e.methodName == methodName));

                        if (duplicate)
                        {
                            EditorUtility.DisplayDialog("Duplicate", "This filter already exists.", "OK");
                        }
                        else
                        {
                            config.entries.Add(new CallstackFilterEntry
                            {
                                typeName = typeName,
                                methodName = m_NewFilterAll ? "" : methodName,
                                filterAllMembers = m_NewFilterAll,
                                enabled = true
                            });
                            changed = true;
                            m_NewTypeName = "";
                            m_NewMethodName = "";
                            m_NewFilterAll = false;
                        }
                    }
                }
            }

            if (GUILayout.Button("Apply Now", GUILayout.Height(24)))
            {
                CallstackFilterRuntime.SaveAndApply();
                Debug.Log("[CallstackFilter] Filters saved and applied.");
            }
            EditorGUILayout.EndHorizontal();

            if (changed)
                CallstackFilterRuntime.SaveAndApply();
        }
    }
}