com.elestrago.unity.generated-code-dump 1.0.0

package/Editor/GeneratedCodeDumpSettingsFile.cs

@@ -0,0 +1,231 @@
+using System.Globalization;
+using System.Text;
+
+namespace GeneratedCodeDump.Editor
+{
+	/// <summary>
+	/// The text of the settings file, <c>{"enabled": true}</c>: written and parsed without
+	/// <c>JsonUtility</c>, so the settings watcher can read it off the main thread. No UnityEditor use.
+	/// </summary>
+	/// <remarks>
+	/// The parser accepts one flat JSON object: string keys, and string, number, true, false or null values.
+	/// <c>enabled</c> must be exactly <c>true</c> or <c>false</c>; a missing <c>enabled</c> means off.
+	/// </remarks>
+	internal static class GeneratedCodeDumpSettingsFile
+	{
+		internal const string EnabledKey = "enabled";
+
+		internal static string Format(bool enabled)
+		{
+			return "{\n    \"" + EnabledKey + "\": " + (enabled ? "true" : "false") + "\n}\n";
+		}
+
+		/// <summary>
+		/// False when <paramref name="json"/> is not a flat JSON object with a boolean <c>enabled</c> (or none).
+		/// </summary>
+		internal static bool TryParse(string json, out bool enabled)
+		{
+			if (Parse(json, out enabled))
+				return true;
+
+			enabled = false;
+			return false;
+		}
+
+		private static bool Parse(string json, out bool enabled)
+		{
+			enabled = false;
+			if (json == null)
+				return false;
+
+			var index = 0;
+			if (json.Length > 0 && json[0] == '\uFEFF')
+				index++;
+
+			SkipWhitespace(json, ref index);
+			if (!Consume(json, ref index, '{'))
+				return false;
+
+			SkipWhitespace(json, ref index);
+			if (Consume(json, ref index, '}'))
+				return AtEnd(json, index);
+
+			while (true)
+			{
+				if (!TryReadString(json, ref index, out var key))
+					return false;
+
+				SkipWhitespace(json, ref index);
+				if (!Consume(json, ref index, ':'))
+					return false;
+
+				SkipWhitespace(json, ref index);
+				if (key == EnabledKey)
+				{
+					if (ConsumeWord(json, ref index, "true"))
+						enabled = true;
+					else if (ConsumeWord(json, ref index, "false"))
+						enabled = false;
+					else
+						return false;
+				}
+				else if (!TrySkipScalar(json, ref index))
+				{
+					return false;
+				}
+
+				SkipWhitespace(json, ref index);
+				if (Consume(json, ref index, ','))
+				{
+					SkipWhitespace(json, ref index);
+					continue;
+				}
+
+				return Consume(json, ref index, '}') && AtEnd(json, index);
+			}
+		}
+
+		private static bool AtEnd(string json, int index)
+		{
+			SkipWhitespace(json, ref index);
+			return index == json.Length;
+		}
+
+		private static void SkipWhitespace(string json, ref int index)
+		{
+			while (index < json.Length && (json[index] == ' ' || json[index] == '\t' || json[index] == '\r' || json[index] == '\n'))
+				index++;
+		}
+
+		private static bool Consume(string json, ref int index, char expected)
+		{
+			if (index >= json.Length || json[index] != expected)
+				return false;
+
+			index++;
+			return true;
+		}
+
+		private static bool ConsumeWord(string json, ref int index, string word)
+		{
+			if (string.CompareOrdinal(json, index, word, 0, word.Length) != 0)
+				return false;
+
+			index += word.Length;
+			return true;
+		}
+
+		private static bool TrySkipScalar(string json, ref int index)
+		{
+			if (index >= json.Length)
+				return false;
+
+			if (json[index] == '"')
+				return TryReadString(json, ref index, out _);
+
+			if (ConsumeWord(json, ref index, "true") || ConsumeWord(json, ref index, "false") || ConsumeWord(json, ref index, "null"))
+				return true;
+
+			return TrySkipNumber(json, ref index);
+		}
+
+		private static bool TrySkipNumber(string json, ref int index)
+		{
+			Consume(json, ref index, '-');
+			if (!SkipDigits(json, ref index))
+				return false;
+
+			if (Consume(json, ref index, '.') && !SkipDigits(json, ref index))
+				return false;
+
+			if (Consume(json, ref index, 'e') || Consume(json, ref index, 'E'))
+			{
+				if (!Consume(json, ref index, '+'))
+					Consume(json, ref index, '-');
+
+				if (!SkipDigits(json, ref index))
+					return false;
+			}
+
+			return true;
+		}
+
+		private static bool SkipDigits(string json, ref int index)
+		{
+			var start = index;
+			while (index < json.Length && json[index] >= '0' && json[index] <= '9')
+				index++;
+
+			return index > start;
+		}
+
+		private static bool TryReadString(string json, ref int index, out string value)
+		{
+			value = null;
+			if (!Consume(json, ref index, '"'))
+				return false;
+
+			var builder = new StringBuilder();
+			while (index < json.Length)
+			{
+				var c = json[index++];
+				if (c == '"')
+				{
+					value = builder.ToString();
+					return true;
+				}
+
+				if (c < ' ')
+					return false;
+
+				if (c != '\\')
+				{
+					builder.Append(c);
+					continue;
+				}
+
+				if (index >= json.Length)
+					return false;
+
+				var escape = json[index++];
+				switch (escape)
+				{
+					case '"':
+					case '\\':
+					case '/':
+						builder.Append(escape);
+						break;
+					case 'b':
+						builder.Append('\b');
+						break;
+					case 'f':
+						builder.Append('\f');
+						break;
+					case 'n':
+						builder.Append('\n');
+						break;
+					case 'r':
+						builder.Append('\r');
+						break;
+					case 't':
+						builder.Append('\t');
+						break;
+					case 'u':
+						if (index + 4 > json.Length
+							|| !int.TryParse(json.Substring(index, 4), NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out var code))
+						{
+							return false;
+						}
+
+						builder.Append((char)code);
+						index += 4;
+						break;
+					default:
+						return false;
+				}
+			}
+
+			return false;
+		}
+	}
+}

package/Editor/GeneratedCodeDumpSettingsFile.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 1c6551acf1d40ead283d5938a39c9ae6

package/Editor/GeneratedCodeDumpSettingsProvider.cs

@@ -0,0 +1,93 @@
+using UnityEditor;
+using UnityEngine;
+
+namespace GeneratedCodeDump.Editor
+{
+	/// <summary>
+	/// Preferences page <c>Preferences/Generated Code Dump</c>: this user's switch for the generated-code dump,
+	/// and its output folder.
+	/// </summary>
+	internal sealed class GeneratedCodeDumpSettingsProvider : SettingsProvider
+	{
+		private static readonly string[] Keywords =
+		{
+			"Generated",
+			"Source Generator",
+			"Roslyn",
+			"Dump"
+		};
+
+		private GUIStyle _panelStyle;
+
+		private GeneratedCodeDumpSettingsProvider()
+			: base(GeneratedCodeDumpIdentity.SettingsPath, SettingsScope.User, Keywords)
+		{
+		}
+
+		[SettingsProvider]
+		private static SettingsProvider Create()
+		{
+			return new GeneratedCodeDumpSettingsProvider();
+		}
+
+		public override void OnGUI(string searchContext)
+		{
+			if (_panelStyle == null)
+				_panelStyle = new GUIStyle { margin = new RectOffset(10, 10, 6, 6) };
+
+			var labelWidth = EditorGUIUtility.labelWidth;
+			EditorGUIUtility.labelWidth = 170;
+
+			using (new EditorGUILayout.VerticalScope(_panelStyle))
+			{
+				EditorGUILayout.HelpBox(
+					"After each compile, replays the compiler of every rebuilt assembly and writes what its source "
+					+ "generators produced to " + GeneratedCodeDumpPaths.Root + "/<Assembly>/<Generator>/, so "
+					+ "tools and AI agents can read the real generated code.",
+					MessageType.None
+				);
+
+				DrawEnableSection();
+				DrawOutputSection();
+			}
+
+			EditorGUIUtility.labelWidth = labelWidth;
+		}
+
+		private static void DrawEnableSection()
+		{
+			EditorGUILayout.Space();
+
+			var current = GeneratedCodeDumpSettings.IsEnabled;
+			var enabled = EditorGUILayout.Toggle(new GUIContent("Dump generated code"), current);
+			if (enabled != current)
+				GeneratedCodeDumper.SetEnabled(enabled);
+
+			EditorGUILayout.HelpBox(
+				"Your own setting for this project: stored in " + GeneratedCodeDumpPaths.SettingsFile
+				+ " (keep UserSettings/ out of version control). An edit to that file applies within a second. Batch mode on this machine "
+				+ "follows it too.\n\nTurning it on, or Dump Now, runs a full dump: it replays every assembly of the "
+				+ "project, at most " + GeneratedCodeDumper.MaxConcurrent + " compilers at a time.",
+				MessageType.Info
+			);
+		}
+
+		private static void DrawOutputSection()
+		{
+			EditorGUILayout.Space();
+			EditorGUILayout.LabelField("Output", EditorStyles.boldLabel);
+			EditorGUILayout.LabelField("Folder", GeneratedCodeDumpPaths.Root + "/");
+
+			using (new EditorGUILayout.HorizontalScope())
+			{
+				GUILayout.Space(EditorGUIUtility.labelWidth);
+
+				if (GUILayout.Button("Open Folder"))
+					GeneratedCodeMenuItems.OpenFolder();
+
+				if (GUILayout.Button("Dump Now"))
+					GeneratedCodeMenuItems.DumpNow();
+			}
+		}
+	}
+}

package/Editor/GeneratedCodeDumpSettingsProvider.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 0542fccb20ec91b35abb5c811d1d3d30

package/Editor/GeneratedCodeDumpSettingsWatcher.cs

@@ -0,0 +1,199 @@
+using System;
+using System.IO;
+using System.Threading;
+using UnityEngine;
+
+namespace GeneratedCodeDump.Editor
+{
+	/// <summary>
+	/// Calls back, off the main thread, about 300 ms after the settings file is created, changed, renamed
+	/// or deleted, so an edit made outside the Editor applies even while the Editor sits in the background.
+	/// Not used in batch mode.
+	/// </summary>
+	/// <remarks>
+	/// Creates nothing: it watches UserSettings/ for <see cref="GeneratedCodeDumpPaths.SettingsFile"/>, and while
+	/// UserSettings/ is missing it watches the project root for that folder only (<see cref="Target"/>).
+	/// Callbacks never overlap, and <see cref="Stop"/> waits for a running one, so none outlives the domain.
+	/// </remarks>
+	internal static class GeneratedCodeDumpSettingsWatcher
+	{
+		private const int DebounceMilliseconds = 300;
+		private const int StopWaitMilliseconds = 2000;
+
+		// CallbackLock is taken before any of the dumper's locks; Sync is held only briefly, never while calling out.
+		private static readonly object CallbackLock = new object();
+		private static readonly object Sync = new object();
+
+		private static FileSystemWatcher _watcher;
+		private static string _watchedFolder;
+		private static Timer _debounce;
+		private static Action _onChange;
+		private static bool _stopped;
+		private static bool _warned;
+
+		internal static void Start(Action onChange)
+		{
+			lock (Sync)
+			{
+				if (_debounce != null)
+					return;
+
+				_onChange = onChange;
+				_stopped = false;
+				_debounce = new Timer(OnDebounced, null, Timeout.Infinite, Timeout.Infinite);
+				Arm();
+			}
+		}
+
+		internal static void Stop()
+		{
+			lock (Sync)
+			{
+				_stopped = true;
+				_debounce?.Dispose();
+				_debounce = null;
+				DisposeWatcher();
+			}
+
+			if (Monitor.TryEnter(CallbackLock, StopWaitMilliseconds))
+				Monitor.Exit(CallbackLock);
+		}
+
+		/// <summary>
+		/// The folder to watch and the name to watch in it for <paramref name="settingsFile"/> (a full path): its
+		/// folder for the file itself, or, while that folder is missing, the folder above for that folder's name.
+		/// </summary>
+		internal static (string Folder, string Filter) Target(string settingsFile, bool settingsFolderExists)
+		{
+			var settingsFolder = Path.GetDirectoryName(settingsFile);
+			return settingsFolderExists
+				? (settingsFolder, Path.GetFileName(settingsFile))
+				: (Path.GetDirectoryName(settingsFolder), Path.GetFileName(settingsFolder));
+		}
+
+		// Under Sync.
+		private static void Arm()
+		{
+			if (_stopped)
+				return;
+
+			try
+			{
+				var settingsFile = GeneratedCodeDumpPaths.ToFullPath(GeneratedCodeDumpPaths.SettingsFile);
+				var settingsFolder = Path.GetDirectoryName(settingsFile);
+				var settingsFolderExists = Directory.Exists(settingsFolder);
+				var (folder, filter) = Target(settingsFile, settingsFolderExists);
+				if (_watcher != null && string.Equals(_watchedFolder, folder, StringComparison.Ordinal))
+					return;
+
+				DisposeWatcher();
+				var watcher = new FileSystemWatcher(folder, filter)
+				{
+					IncludeSubdirectories = false,
+					NotifyFilter = NotifyFilters.FileName | NotifyFilters.DirectoryName | NotifyFilters.LastWrite | NotifyFilters.Size
+						| NotifyFilters.CreationTime
+				};
+				watcher.Changed += OnChanged;
+				watcher.Created += OnChanged;
+				watcher.Deleted += OnChanged;
+				watcher.Renamed += OnRenamed;
+				watcher.Error += OnError;
+				watcher.EnableRaisingEvents = true;
+				_watcher = watcher;
+				_watchedFolder = folder;
+
+				// The folder may have appeared between the check and the watcher starting.
+				if (!settingsFolderExists && Directory.Exists(settingsFolder))
+					Schedule();
+			}
+			catch (Exception exception)
+			{
+				Warn(exception);
+			}
+		}
+
+		private static void DisposeWatcher()
+		{
+			var watcher = _watcher;
+			_watcher = null;
+			_watchedFolder = null;
+			if (watcher == null)
+				return;
+
+			try
+			{
+				watcher.EnableRaisingEvents = false;
+				watcher.Dispose();
+			}
+			catch (Exception)
+			{
+				// Already broken; nothing more to release.
+			}
+		}
+
+		private static void OnChanged(object sender, FileSystemEventArgs args)
+		{
+			Schedule();
+		}
+
+		private static void OnRenamed(object sender, RenamedEventArgs args)
+		{
+			Schedule();
+		}
+
+		private static void OnError(object sender, ErrorEventArgs args)
+		{
+			// Re-created by the next callback, e.g. after the watched folder was deleted.
+			lock (Sync)
+				DisposeWatcher();
+
+			Schedule();
+		}
+
+		private static void Schedule()
+		{
+			lock (Sync)
+			{
+				if (!_stopped)
+					_debounce?.Change(DebounceMilliseconds, Timeout.Infinite);
+			}
+		}
+
+		private static void OnDebounced(object state)
+		{
+			lock (CallbackLock)
+			{
+				Action onChange;
+				lock (Sync)
+				{
+					if (_stopped)
+						return;
+
+					Arm();
+					onChange = _onChange;
+				}
+
+				try
+				{
+					onChange?.Invoke();
+				}
+				catch (Exception exception)
+				{
+					Warn(exception);
+				}
+			}
+		}
+
+		private static void Warn(Exception exception)
+		{
+			if (_warned)
+				return;
+
+			_warned = true;
+			Debug.LogWarning(
+				$"{GeneratedCodeDumpIdentity.LogPrefix}watching {GeneratedCodeDumpPaths.SettingsFile} failed: {exception.Message} "
+				+ "An edit to it made outside the Editor now applies on the next compile."
+			);
+		}
+	}
+}

package/Editor/GeneratedCodeDumpSettingsWatcher.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 0793a6e07150a36d191da1bf1573adbd