Merge mono changes into il2cpp; fix resulting issues

Author: ManlyMarco

RuntimeUnityEditor.Bepin6.IL2CPP/LogViewer/LogViewerEntry.cs

@@ -0,0 +1,210 @@
+using System;
+using System.Diagnostics;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+using BepInEx.Logging;
+using RuntimeUnityEditor.Core;
+using RuntimeUnityEditor.Core.Utils;
+using UnityEngine;
+
+namespace RuntimeUnityEditor.Bepin6.LogViewer
+{
+    internal readonly struct LogViewerEntry
+    {
+        private LogViewerEntry(object sender, LogEventArgs logEventArgs, StackFrame[] filteredStackTrace, string filteredStackTraceString)
+        {
+            Sender = sender;
+            LogEventArgs = logEventArgs;
+            FilteredStackTrace = filteredStackTrace;
+            FilteredStackTraceString = filteredStackTraceString;
+
+            Method = filteredStackTrace != null && filteredStackTrace.Length > 0 ? filteredStackTrace[0].GetMethod() : null;
+
+            var tooltip = "Filtered stack trace of this log write:\n\n" + filteredStackTraceString;
+            _timeString = new GUIContent(DateTime.UtcNow.ToShortTimeString(), null, tooltip);
+            _logLevelString = new GUIContent(logEventArgs.Level.ToString(), null, tooltip);
+            _sourceNameString = new GUIContent(logEventArgs.Source.SourceName, null, tooltip);
+            _dataString = new GUIContent(logEventArgs.Data?.ToString() ?? "NULL", null, tooltip);
+            //ContentLevel = new GUIContent($"{_TimeString} [{_logLevelString,-7}:{_sourceSourceNameString,10}]", tooltip);
+            //ContentText = new GUIContent(_dataString, tooltip);
+        }
+
+        private readonly GUIContent _timeString;
+        private readonly GUIContent _logLevelString;
+        private readonly GUIContent _sourceNameString;
+        private readonly GUIContent _dataString;
+
+        public MethodBase Method { get; }
+        //public GUIContent ContentLevel { get; }
+        //public GUIContent ContentText { get; }
+        public LogEventArgs LogEventArgs { get; }
+        public StackFrame[] FilteredStackTrace { get; }
+        public string FilteredStackTraceString { get; }
+        public object Sender { get; }
+
+        public string GetClipboardString()
+        {
+            return $"{_timeString} {_logLevelString} {_sourceNameString} {_dataString}\n{FilteredStackTraceString}\nSender: {Sender} ({Sender?.GetType().GetSourceCodeRepresentation() ?? "NULL"})";
+        }
+
+        public bool DrawEntry()
+        {
+            GUI.color = GetColor();
+            var clicked = GUILayout.Button(_timeString, GUI.skin.label, GUILayout.MinWidth(35));
+            GUILayout.Label("[", IMGUIUtils.LayoutOptionsExpandWidthFalse);
+            clicked |= GUILayout.Button(_logLevelString, GUI.skin.label, GUILayout.MinWidth(45));
+            GUILayout.Label(":", IMGUIUtils.LayoutOptionsExpandWidthFalse);
+            clicked |= GUILayout.Button(_sourceNameString, GUI.skin.label, GUILayout.MinWidth(100));
+            GUILayout.Label("]", IMGUIUtils.LayoutOptionsExpandWidthFalse);
+            GUI.color = Color.white;
+            clicked |= GUILayout.Button(_dataString, GUI.skin.label, IMGUIUtils.LayoutOptionsExpandWidthTrue);
+            return clicked;
+        }
+
+        public Color GetColor()
+        {
+            switch (LogEventArgs.Level)
+            {
+                case LogLevel.Fatal:
+                case LogLevel.Error:
+                    return Color.red;
+
+                case LogLevel.Warning:
+                    return Color.yellow;
+
+                default:
+                case LogLevel.Message:
+                case LogLevel.Info:
+                    return Color.white;
+
+                case LogLevel.Debug:
+                    return Color.gray;
+            }
+        }
+
+        public bool IsMatch(string searchString, LogLevel logLevelFilter)
+        {
+            return (logLevelFilter & LogEventArgs.Level) != 0
+                   && (string.IsNullOrEmpty(searchString)
+                       || _dataString.text.Contains(searchString, StringComparison.OrdinalIgnoreCase)
+                       || FilteredStackTraceString.Contains(searchString, StringComparison.OrdinalIgnoreCase)
+                       || LogEventArgs.Source.SourceName.Contains(searchString, StringComparison.OrdinalIgnoreCase));
+        }
+
+        #region Parsing
+
+        private const int SkippedStackFrames = 4;
+        private static bool _stacktraceTostringFallback;
+
+        public static LogViewerEntry CreateFromLogEventArgs(object sender, LogEventArgs eventArgs)
+        {
+            string hoverText;
+            var st = new StackTrace(SkippedStackFrames);
+            StackFrame[] frames = null;
+
+        fallback:
+            if (!_stacktraceTostringFallback)
+            {
+                try
+                {
+                    // Try to trim the stack trace up until user code and reduce the amount of text shown so it fits in the tooltip
+                    hoverText = ParseStackTrace(st, out frames);
+                }
+                catch (Exception e)
+                {
+                    RuntimeUnityEditorCore.Logger.Log(Core.Utils.Abstractions.LogLevel.Error, $"[{nameof(LogViewerWindow)}] Crash when trying to parse stack trace, falling back to using ToString\n" + e);
+                    _stacktraceTostringFallback = true;
+                    goto fallback;
+                }
+            }
+            else
+            {
+                hoverText = ParseStackTraceString(st);
+                try
+                {
+                    frames = st.GetFrames();
+                }
+                catch (Exception e)
+                {
+                    Console.WriteLine(e);
+                }
+            }
+
+            return new LogViewerEntry(sender, eventArgs, frames, hoverText);
+        }
+        
+        private static string ParseStackTrace(StackTrace st, out StackFrame[] filteredFrames)
+        {
+            filteredFrames = null;
+
+            var frames = st.GetFrames();
+            if (frames == null || frames.Length == 0)
+                return ParseStackTraceString(st);
+
+            var sb = new StringBuilder();
+            var realEncountered = false;
+            var firstRealIdx = 0;
+            //var skipped = 0;
+            for (var i = 0; i < frames.Length; i++)
+            {
+                var frame = frames[i];
+                var m = frame.GetMethod();
+                var mName = m.Name;
+                var typeName = (m.DeclaringType ?? m.ReflectedType)?.GetSourceCodeRepresentation() ?? "???";
+
+                var first = false;
+                if (!realEncountered)
+                {
+                    if (typeName.StartsWith("BepInEx.", StringComparison.Ordinal) ||
+                        typeName.StartsWith("System.", StringComparison.Ordinal) ||
+                        typeName.StartsWith("UnityEngine.", StringComparison.Ordinal) && mName.Contains("Log", StringComparison.Ordinal) ||
+                        typeName.StartsWith(nameof(RuntimeUnityEditor), StringComparison.Ordinal) && mName.Equals("Log", StringComparison.Ordinal))
+                    {
+                        //skipped++;
+                        continue;
+                    }
+
+                    realEncountered = true;
+                    first = true;
+                }
+
+                if (first)
+                    firstRealIdx = i;
+
+                sb.AppendFormat("[{0}] ", i + SkippedStackFrames);
+                sb.Append(typeName);
+                sb.Append('.');
+                sb.Append(mName);
+                //todo params
+                sb.AppendLine();
+            }
+
+            //if (skipped > 0)
+            //    sb.AppendLine($"(The stack trace starts at frame {4 + skipped})");
+
+            filteredFrames = frames.Skip(firstRealIdx).ToArray();
+
+            if (sb.Length == 0)
+                sb.Append(@"¯\_(ツ)_/¯");
+
+            return sb.ToString();
+        }
+
+        private static string ParseStackTraceString(StackTrace st)
+        {
+            var parts = st.ToString().Split(new[] { '\n', '\r' }, StringSplitOptions.RemoveEmptyEntries);
+            var firstGood = Array.FindIndex(parts, part => !part.Contains("at BepInEx.") && !part.Contains("at System."));
+            if (firstGood >= 0)
+            {
+                var temp = new string[parts.Length - firstGood];
+                Array.Copy(parts, firstGood, temp, 0, parts.Length - firstGood);
+                return "Origin: " + string.Join("\n", temp);
+            }
+
+            return string.Empty;
+        }
+
+        #endregion
+    }
+}

RuntimeUnityEditor.Bepin6.IL2CPP/LogViewer/LogViewerListener.cs

@@ -0,0 +1,39 @@
+using System;
+using BepInEx.Logging;
+using RuntimeUnityEditor.Core;
+
+namespace RuntimeUnityEditor.Bepin6.LogViewer
+{
+    internal sealed class LogViewerListener : ILogListener
+    {
+        private readonly LogViewerWindow _owner;
+
+        public LogViewerListener(LogViewerWindow owner)
+        {
+            _owner = owner;
+        }
+
+        public void Dispose()
+        {
+
+        }
+
+        public void LogEvent(object sender, LogEventArgs eventArgs)
+        {
+            if ((_owner.LogLevelFilter & eventArgs.Level) == 0)
+                return;
+
+            try
+            {
+                _owner.OnLogEvent(sender, eventArgs);
+            }
+            catch (Exception e)
+            {
+                RuntimeUnityEditorCore.Logger.Log(Core.Utils.Abstractions.LogLevel.Error, $"[{nameof(LogViewerWindow)}] Unexpected crash when trying to parse stack trace, disabling log capture!" + e);
+                _owner.Capture = false;
+            }
+        }
+
+        public LogLevel LogLevelFilter { get; } = LogLevel.All;
+    }
+}