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

package/Editor/GeneratedCodeDump.Editor.asmdef

@@ -0,0 +1,16 @@
+{
+	"name": "GeneratedCodeDump.Editor",
+	"rootNamespace": "GeneratedCodeDump.Editor",
+	"references": [],
+	"includePlatforms": [
+		"Editor"
+	],
+	"excludePlatforms": [],
+	"allowUnsafeCode": false,
+	"overrideReferences": false,
+	"precompiledReferences": [],
+	"autoReferenced": true,
+	"defineConstraints": [],
+	"versionDefines": [],
+	"noEngineReferences": false
+}

package/Editor/GeneratedCodeDump.Editor.asmdef.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 0a87005cb0ee4bafe95e7967dcf0e672
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Editor/GeneratedCodeDumpArgs.cs

@@ -0,0 +1,113 @@
+using System;
+using System.Collections.Generic;
+
+namespace GeneratedCodeDump.Editor
+{
+	/// <summary>
+	/// Reads and rewrites a Unity compiler response file (one argument per line) so it can be replayed
+	/// with generated-files output, without overwriting any of Unity's own outputs. No UnityEditor use.
+	/// </summary>
+	internal static class GeneratedCodeDumpArgs
+	{
+		private static readonly string[] AnalyzerArgNames = { "analyzer" };
+
+		// Every argument that makes csc write a file: redirected so the replay never touches Library/Bee.
+		private static readonly string[] OutputArgNames =
+		{
+			"out",
+			"refout",
+			"doc",
+			"pdb",
+			"errorlog",
+			"generatedfilesout"
+		};
+
+		/// <summary>
+		/// True when the compilation loads at least one analyzer (<c>-analyzer:</c> or <c>/analyzer:</c>, any
+		/// case). Without one no source generator runs, so a replay could produce nothing.
+		/// </summary>
+		internal static bool HasAnalyzer(IEnumerable<string> lines)
+		{
+			foreach (var line in lines)
+			{
+				if (TryParse(line, out var name, out var value) && IsAny(name, AnalyzerArgNames) && value.Trim('"').Length > 0)
+					return true;
+			}
+
+			return false;
+		}
+
+		/// <summary>
+		/// Drops every output-writing argument (both '-' and '/' prefixes, any case) and appends
+		/// <c>-out</c>, <c>-refout</c>, <c>-generatedfilesout</c> and <c>-errorlog</c> with quoted paths.
+		/// Every other line is kept unchanged and in order.
+		/// </summary>
+		internal static List<string> Rewrite(
+			IEnumerable<string> lines,
+			string outDll,
+			string refDll,
+			string generatedDir,
+			string errorLog
+		)
+		{
+			var result = new List<string>();
+			foreach (var line in lines)
+			{
+				if (TryParse(line, out var name, out _) && IsAny(name, OutputArgNames))
+					continue;
+
+				result.Add(line);
+			}
+
+			result.Add("-out:" + Quote(outDll));
+			result.Add("-refout:" + Quote(refDll));
+			result.Add("-generatedfilesout:" + Quote(generatedDir));
+			result.Add("-errorlog:" + Quote(errorLog));
+			return result;
+		}
+
+		// Parses "-name:value" or "/name:value". The name must be letters only, so an absolute Unix source
+		// path such as "/home/me/a:b.cs" is not mistaken for an option.
+		private static bool TryParse(string line, out string name, out string value)
+		{
+			name = null;
+			value = null;
+			if (line == null)
+				return false;
+
+			var text = line.Trim();
+			if (text.Length < 3 || (text[0] != '-' && text[0] != '/'))
+				return false;
+
+			var colon = text.IndexOf(':');
+			if (colon < 2)
+				return false;
+
+			for (var i = 1; i < colon; i++)
+			{
+				if (!char.IsLetter(text[i]))
+					return false;
+			}
+
+			name = text.Substring(1, colon - 1);
+			value = text.Substring(colon + 1).Trim();
+			return true;
+		}
+
+		private static bool IsAny(string name, string[] candidates)
+		{
+			foreach (var candidate in candidates)
+			{
+				if (string.Equals(name, candidate, StringComparison.OrdinalIgnoreCase))
+					return true;
+			}
+
+			return false;
+		}
+
+		private static string Quote(string path)
+		{
+			return "\"" + path + "\"";
+		}
+	}
+}

package/Editor/GeneratedCodeDumpArgs.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 7cd57e31d76c7c68ba92d3ab78c5fc40

package/Editor/GeneratedCodeDumpFiles.cs

@@ -0,0 +1,120 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Text;
+
+namespace GeneratedCodeDump.Editor
+{
+	/// <summary>
+	/// File helpers shared by the dump's state files (settings, jobs, session marker) and its work folders.
+	/// No UnityEditor use, so every thread can call them.
+	/// </summary>
+	internal static class GeneratedCodeDumpFiles
+	{
+		internal static readonly Encoding Utf8NoBom = new UTF8Encoding(false);
+
+		/// <summary>
+		/// Writes <paramref name="text"/> to <c>&lt;path&gt;.tmp</c>, then moves it over <paramref name="path"/>,
+		/// so a reader, or an Editor that stops mid-write, never sees half a file. Creates the folder.
+		/// </summary>
+		internal static void WriteAtomic(string path, string text)
+		{
+			Directory.CreateDirectory(Path.GetDirectoryName(path));
+			var temp = path + ".tmp";
+			try
+			{
+				File.WriteAllText(temp, text, Utf8NoBom);
+				if (File.Exists(path))
+					File.Replace(temp, path, null);
+				else
+					File.Move(temp, path);
+			}
+			finally
+			{
+				TryDeleteFile(temp);
+			}
+		}
+
+		/// <summary>
+		/// The file's text, or null when it does not exist. Any other failure throws, so a caller never takes
+		/// a file it could not read for an empty one.
+		/// </summary>
+		internal static string ReadTextOrNull(string path)
+		{
+			try
+			{
+				return File.ReadAllText(path);
+			}
+			catch (Exception exception) when (exception is FileNotFoundException || exception is DirectoryNotFoundException)
+			{
+				return null;
+			}
+		}
+
+		/// <summary>
+		/// Creates the folder and, on Windows, marks it Hidden, so Explorer lists only what sits next to it.
+		/// Failing to mark it is ignored.
+		/// </summary>
+		internal static void CreateHiddenDirectory(string path)
+		{
+			Directory.CreateDirectory(path);
+			if (Environment.OSVersion.Platform != PlatformID.Win32NT)
+				return;
+
+			try
+			{
+				var attributes = File.GetAttributes(path);
+				if ((attributes & FileAttributes.Hidden) == 0)
+					File.SetAttributes(path, attributes | FileAttributes.Hidden);
+			}
+			catch (Exception)
+			{
+				// Only cosmetic.
+			}
+		}
+
+		internal static void DeleteDirectory(string path)
+		{
+			if (Directory.Exists(path))
+				Directory.Delete(path, true);
+		}
+
+		internal static void TryDeleteDirectory(string path)
+		{
+			try
+			{
+				DeleteDirectory(path);
+			}
+			catch (Exception exception) when (exception is IOException || exception is UnauthorizedAccessException)
+			{
+				// Held open by another process; the next dump retries.
+			}
+		}
+
+		internal static void TryDeleteEmptyDirectory(string path)
+		{
+			try
+			{
+				if (Directory.Exists(path) && !Directory.EnumerateFileSystemEntries(path).Any())
+					Directory.Delete(path);
+			}
+			catch (Exception exception) when (exception is IOException || exception is UnauthorizedAccessException)
+			{
+				// Not empty any more, or held open; the next dump retries.
+			}
+		}
+
+		internal static void TryDeleteFile(string path)
+		{
+			try
+			{
+				if (File.Exists(path))
+					File.Delete(path);
+			}
+			catch (Exception exception) when (exception is IOException || exception is UnauthorizedAccessException)
+			{
+				// Held open by another process; harmless.
+			}
+		}
+	}
+}

package/Editor/GeneratedCodeDumpFiles.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 27037c0fa6604100f84709b12a23b65b

package/Editor/GeneratedCodeDumpFinisher.cs

@@ -0,0 +1,103 @@
+using System;
+using System.Threading;
+using UnityEngine;
+
+namespace GeneratedCodeDump.Editor
+{
+	/// <summary>
+	/// Background thread that runs <see cref="GeneratedCodeDumper.Tick"/> every 250 ms while there are jobs:
+	/// it starts queued replays and moves the output of finished ones into the dump. Unlike
+	/// <c>EditorApplication.update</c>, it keeps going while the Editor sits in the background. Not used in
+	/// batch mode, which finishes the jobs on the calling thread.
+	/// </summary>
+	/// <remarks>
+	/// Stopped before each domain reload and on quit, waiting up to 2 s for the current tick. A tick cut short
+	/// by the reload is repeated by the next domain: a job is removed only after its output is in place.
+	/// </remarks>
+	internal static class GeneratedCodeDumpFinisher
+	{
+		private const int TickMilliseconds = 250;
+		private const int JoinMilliseconds = 2000;
+
+		private static readonly object ThreadLock = new object();
+		private static readonly ManualResetEvent StopSignal = new ManualResetEvent(false);
+
+		private static Thread _thread;
+		private static volatile bool _stopping;
+		private static bool _warned;
+
+		internal static bool IsStopping => _stopping;
+
+		/// <summary>
+		/// Starts the thread unless it runs already. Call it after adding jobs.
+		/// </summary>
+		internal static void Start()
+		{
+			lock (ThreadLock)
+			{
+				if (_thread != null || _stopping)
+					return;
+
+				_thread = new Thread(Loop) { IsBackground = true, Name = GeneratedCodeDumpIdentity.ThreadName };
+				_thread.Start();
+			}
+		}
+
+		internal static void Stop()
+		{
+			Thread thread;
+			lock (ThreadLock)
+			{
+				_stopping = true;
+				thread = _thread;
+			}
+
+			StopSignal.Set();
+			thread?.Join(JoinMilliseconds);
+		}
+
+		private static void Loop()
+		{
+			try
+			{
+				while (!_stopping)
+				{
+					GeneratedCodeDumper.Tick();
+
+					// Decided under the lock that Start takes, so a job added meanwhile either sees this thread
+					// still running or starts a new one.
+					lock (ThreadLock)
+					{
+						if (_stopping || !GeneratedCodeDumper.HasJobs())
+						{
+							_thread = null;
+							return;
+						}
+					}
+
+					StopSignal.WaitOne(TickMilliseconds);
+				}
+			}
+			catch (ThreadAbortException)
+			{
+				// The domain is unloading; the next one picks the jobs up.
+			}
+			catch (Exception exception)
+			{
+				if (!_warned)
+				{
+					_warned = true;
+					Debug.LogWarning($"{GeneratedCodeDumpIdentity.LogPrefix}the background dump stopped: {exception.Message} It restarts with the next dump.");
+				}
+			}
+			finally
+			{
+				lock (ThreadLock)
+				{
+					if (_thread == Thread.CurrentThread)
+						_thread = null;
+				}
+			}
+		}
+	}
+}

package/Editor/GeneratedCodeDumpFinisher.cs.meta

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

package/Editor/GeneratedCodeDumpIdentity.cs

@@ -0,0 +1,40 @@
+namespace GeneratedCodeDump.Editor
+{
+	/// <summary>
+	/// Every name by which the generated-code dump shows itself: its Library/ folder, log prefix, thread,
+	/// temp folder, menu and Preferences page.
+	/// </summary>
+	internal static class GeneratedCodeDumpIdentity
+	{
+		/// <summary>
+		/// The package name. A constant because <c>PackageInfo.FindForAssembly</c> returns null when the package
+		/// sits under Assets/. Up to 1.0.0 it was also the folder name under Library/
+		/// (<see cref="GeneratedCodeDumpPaths.LegacyRoot"/>).
+		/// </summary>
+		internal const string PackageName = "com.elestrago.unity.generated-code-dump";
+
+		/// <summary>
+		/// The folder under Library/ that holds the dump and its <c>.work/</c> folder, kept short for Windows'
+		/// 260-character path limit.
+		/// </summary>
+		internal const string LibraryFolderName = "GeneratedCodeDump";
+
+		internal const string DisplayName = "Generated Code Dump";
+		internal const string LogPrefix = "[" + DisplayName + "] ";
+		internal const string ThreadName = "Generated code dump";
+
+		/// <summary>
+		/// Folder under the system temp folder that holds the compiler outputs, kept short for Windows'
+		/// 260-character path limit.
+		/// </summary>
+		internal const string ScratchFolderName = "GenDump";
+
+		/// <summary>
+		/// The temp folder's name up to 1.0.0. The migration deletes this project's folder in it.
+		/// </summary>
+		internal const string LegacyScratchFolderName = "GCDump";
+
+		internal const string MenuRoot = "Tools/" + DisplayName + "/";
+		internal const string SettingsPath = "Preferences/" + DisplayName;
+	}
+}

package/Editor/GeneratedCodeDumpIdentity.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 5009172e06842333db14c3b3467eaf94

package/Editor/GeneratedCodeDumpJobs.cs

@@ -0,0 +1,242 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Text;
+
+namespace GeneratedCodeDump.Editor
+{
+	/// <summary>
+	/// Where a dump job stands: waiting for a free compiler slot, or its compiler started.
+	/// </summary>
+	internal enum GeneratedCodeDumpJobState
+	{
+		Queued,
+		Running
+	}
+
+	/// <summary>
+	/// One requested replay of an assembly whose output is not in the dump folder yet.
+	/// </summary>
+	internal sealed class GeneratedCodeDumpJob
+	{
+		internal long Id;
+		internal string Assembly;
+		internal GeneratedCodeDumpJobState State;
+		internal int ProcessId;
+		internal long ProcessStartUtcTicks;
+
+		/// <summary>
+		/// UTC wall time when the compiler was started: the job's timeout counts from it, and it is the
+		/// <c>Dumped:</c> time of the files.
+		/// </summary>
+		internal long StartedUtcTicks;
+
+		/// <summary>
+		/// A dump of the assembly was asked while its compiler ran: replay again once it is done.
+		/// </summary>
+		internal bool Rerun;
+	}
+
+	/// <summary>
+	/// The content of the job store: the jobs, at most one per assembly, and the next id to hand out.
+	/// </summary>
+	internal sealed class GeneratedCodeDumpJobList
+	{
+		internal readonly List<GeneratedCodeDumpJob> Jobs = new List<GeneratedCodeDumpJob>();
+		internal long NextId = 1;
+
+		internal GeneratedCodeDumpJob Find(string assembly)
+		{
+			return Jobs.Find(job => string.Equals(job.Assembly, assembly, StringComparison.Ordinal));
+		}
+
+		internal GeneratedCodeDumpJob FindById(long id)
+		{
+			return Jobs.Find(job => job.Id == id);
+		}
+
+		/// <summary>
+		/// Adds a queued job for <paramref name="assembly"/> with a fresh id.
+		/// </summary>
+		internal GeneratedCodeDumpJob Add(string assembly)
+		{
+			var job = new GeneratedCodeDumpJob { Id = NextId++, Assembly = assembly, State = GeneratedCodeDumpJobState.Queued };
+			Jobs.Add(job);
+			return job;
+		}
+
+		/// <summary>
+		/// Drops every replay that has not started: the queued jobs, and the reruns asked of running ones.
+		/// Returns whether anything changed.
+		/// </summary>
+		internal bool DropNotStarted()
+		{
+			var changed = Jobs.RemoveAll(job => job.State == GeneratedCodeDumpJobState.Queued) > 0;
+			foreach (var job in Jobs.Where(job => job.Rerun))
+			{
+				job.Rerun = false;
+				changed = true;
+			}
+
+			return changed;
+		}
+	}
+
+	/// <summary>
+	/// The dump jobs, stored in <see cref="GeneratedCodeDumpPaths.JobsFile"/> so they outlive the domain
+	/// reload that follows every compile, and an Editor restart. Ids only ever go up, so a new job never
+	/// reuses the scratch folder of an old one.
+	/// </summary>
+	/// <remarks>
+	/// Format: a <c>next &lt;id&gt;</c> line, then one tab-separated line per job:
+	/// <c>job, id, queued|running, rerun 0|1, process id, process start ticks, started ticks, assembly</c>.
+	/// <see cref="Read"/> and <see cref="Write"/> hold a lock of their own; a read-modify-write also needs
+	/// the dumper's gate, which callers take outside of it.
+	/// </remarks>
+	internal static class GeneratedCodeDumpJobs
+	{
+		private const string NextTag = "next";
+		private const string JobTag = "job";
+		private const string QueuedName = "queued";
+		private const string RunningName = "running";
+		private const int JobFieldCount = 8;
+
+		private static readonly object FileLock = new object();
+
+		/// <summary>
+		/// The jobs in <paramref name="path"/>; none when the file does not exist. Throws when it exists but
+		/// cannot be read, so a caller never overwrites jobs it did not see.
+		/// </summary>
+		internal static GeneratedCodeDumpJobList Read(string path)
+		{
+			lock (FileLock)
+			{
+				var text = GeneratedCodeDumpFiles.ReadTextOrNull(path);
+				return text == null ? new GeneratedCodeDumpJobList() : Parse(text);
+			}
+		}
+
+		internal static void Write(string path, GeneratedCodeDumpJobList list)
+		{
+			lock (FileLock)
+				GeneratedCodeDumpFiles.WriteAtomic(path, Format(list));
+		}
+
+		internal static bool Any(string path)
+		{
+			return Read(path).Jobs.Count > 0;
+		}
+
+		internal static string Format(GeneratedCodeDumpJobList list)
+		{
+			var builder = new StringBuilder();
+			builder.Append(NextTag).Append(' ').Append(ValidNextId(list).ToString(CultureInfo.InvariantCulture)).Append('\n');
+
+			foreach (var job in list.Jobs.OrderBy(job => job.Id))
+			{
+				builder.Append(JobTag)
+					.Append('\t').Append(job.Id.ToString(CultureInfo.InvariantCulture))
+					.Append('\t').Append(job.State == GeneratedCodeDumpJobState.Running ? RunningName : QueuedName)
+					.Append('\t').Append(job.Rerun ? '1' : '0')
+					.Append('\t').Append(job.ProcessId.ToString(CultureInfo.InvariantCulture))
+					.Append('\t').Append(job.ProcessStartUtcTicks.ToString(CultureInfo.InvariantCulture))
+					.Append('\t').Append(job.StartedUtcTicks.ToString(CultureInfo.InvariantCulture))
+					.Append('\t').Append(job.Assembly)
+					.Append('\n');
+			}
+
+			return builder.ToString();
+		}
+
+		/// <summary>
+		/// Parses <see cref="Format"/>'s output. A malformed line, or a second job with an id or assembly
+		/// already seen, is skipped; <see cref="GeneratedCodeDumpJobList.NextId"/> always ends above the
+		/// highest job id.
+		/// </summary>
+		internal static GeneratedCodeDumpJobList Parse(string text)
+		{
+			var list = new GeneratedCodeDumpJobList();
+			var next = 1L;
+
+			foreach (var rawLine in text.Split('\n'))
+			{
+				var line = rawLine.TrimEnd('\r');
+				if (line.Length == 0)
+					continue;
+
+				if (line.StartsWith(NextTag + " ", StringComparison.Ordinal))
+				{
+					if (TryParseLong(line.Substring(NextTag.Length + 1), out var value) && value > next)
+						next = value;
+
+					continue;
+				}
+
+				if (TryParseJob(line, out var job) && list.FindById(job.Id) == null && list.Find(job.Assembly) == null)
+					list.Jobs.Add(job);
+			}
+
+			list.NextId = next;
+			list.NextId = ValidNextId(list);
+			return list;
+		}
+
+		private static long ValidNextId(GeneratedCodeDumpJobList list)
+		{
+			var next = Math.Max(1, list.NextId);
+			foreach (var job in list.Jobs)
+				next = Math.Max(next, job.Id + 1);
+
+			return next;
+		}
+
+		private static bool TryParseJob(string line, out GeneratedCodeDumpJob job)
+		{
+			job = null;
+			var fields = line.Split('\t');
+			if (fields.Length != JobFieldCount || fields[0] != JobTag)
+				return false;
+
+			GeneratedCodeDumpJobState state;
+			if (fields[2] == QueuedName)
+				state = GeneratedCodeDumpJobState.Queued;
+			else if (fields[2] == RunningName)
+				state = GeneratedCodeDumpJobState.Running;
+			else
+				return false;
+
+			if (fields[3] != "0" && fields[3] != "1")
+				return false;
+
+			if (!TryParseLong(fields[1], out var id) || id < 1
+				|| !int.TryParse(fields[4], NumberStyles.None, CultureInfo.InvariantCulture, out var processId)
+				|| !TryParseLong(fields[5], out var processStart)
+				|| !TryParseLong(fields[6], out var started))
+			{
+				return false;
+			}
+
+			var assembly = fields[7];
+			if (assembly.Length == 0 || assembly.Trim().Length != assembly.Length)
+				return false;
+
+			job = new GeneratedCodeDumpJob
+			{
+				Id = id,
+				Assembly = assembly,
+				State = state,
+				Rerun = fields[3] == "1",
+				ProcessId = processId,
+				ProcessStartUtcTicks = processStart,
+				StartedUtcTicks = started
+			};
+			return true;
+		}
+
+		private static bool TryParseLong(string text, out long value)
+		{
+			return long.TryParse(text, NumberStyles.None, CultureInfo.InvariantCulture, out value);
+		}
+	}
+}

package/Editor/GeneratedCodeDumpJobs.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 9f20fece949bcb66abcec1781868482b