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

package/Editor/GeneratedCodeDumper.cs

@@ -0,0 +1,689 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text.RegularExpressions;
+using System.Threading;
+using UnityEditor;
+using UnityEditor.Compilation;
+using UnityEngine;
+using Debug = UnityEngine.Debug;
+
+namespace GeneratedCodeDump.Editor
+{
+	/// <summary>
+	/// After each compile, replays Unity's compiler response file of every rebuilt assembly that loads an
+	/// analyzer, with <c>-generatedfilesout</c>, so the files every source generator produced land in
+	/// <c>Library/GeneratedCodeDump/&lt;Assembly&gt;/&lt;GeneratorAssembly&gt;/</c>. The replay writes its
+	/// assemblies to the job's temp folder and never touches Unity's own Library/Bee outputs.
+	/// </summary>
+	/// <remarks>
+	/// <para>
+	/// A requested dump becomes a queued job in <see cref="GeneratedCodeDumpJobs"/>; at most
+	/// <see cref="MaxConcurrent"/> compilers run at once, and at most one job per assembly exists: a dump
+	/// asked for a queued assembly is already covered, one asked while its compiler runs replays it again
+	/// afterwards. The compiler runs as a background process with no redirected output (an unread pipe dies
+	/// with the domain and can take the compiler with it); diagnostics go to <c>.work/&lt;Assembly&gt;/errors.sarif</c>,
+	/// generated files and assemblies to the job's folder in <see cref="GeneratedCodeDumpPaths.ScratchRoot"/>.
+	/// <see cref="GeneratedCodeDumpFinisher"/> starts queued jobs and moves finished output into the dump layout
+	/// (<see cref="GeneratedCodeDumpOutput"/>).
+	/// </para>
+	/// <para>
+	/// Batch mode has no finisher thread: each request waits for its jobs, since the Editor can quit right
+	/// after. That includes the full dump the static constructor starts when the dump has just turned on, so a
+	/// CI or agent-launched Editor with the dump on blocks until the dump is complete.
+	/// </para>
+	/// <para>
+	/// Lock order, outermost first: <see cref="SessionLock"/>, <see cref="Gate"/>, the finisher's thread lock,
+	/// the job store's file lock. Every read-modify-write of the jobs holds <see cref="Gate"/>. Nothing here
+	/// calls Unity API off the main thread: the paths, the compiler and the batch-mode flag are read once, on
+	/// the main thread, by the static constructor. Any failure is a warning; nothing throws into Unity's
+	/// callbacks.
+	/// </para>
+	/// </remarks>
+	[InitializeOnLoad]
+	internal static class GeneratedCodeDumper
+	{
+		private const string StampFormat = "yyyy-MM-dd HH:mm:ss 'UTC'";
+		private const double JobTimeoutSeconds = 300;
+		private const int BatchPollMilliseconds = 50;
+
+		/// <summary>
+		/// Compilers that may run at once: half the logical processors, between 1 and 8.
+		/// </summary>
+		internal static readonly int MaxConcurrent = Math.Max(1, Math.Min(8, Environment.ProcessorCount / 2));
+
+		private static readonly object SessionLock = new object();
+		private static readonly object Gate = new object();
+		private static readonly List<string> CompiledAssemblies = new List<string>();
+		private static readonly Regex SarifError = new Regex("\"level\"\\s*:\\s*\"error\"");
+
+		private static volatile bool _unavailable;
+		private static volatile bool _compiling;
+		private static bool _isBatchMode;
+		private static bool _batchGaveUp;
+		private static string _dotnet;
+		private static string _csc;
+
+		static GeneratedCodeDumper()
+		{
+			try
+			{
+				// An import worker is a separate Editor process; it must never start dumps of its own.
+				if (AssetDatabase.IsAssetImportWorkerProcess())
+					return;
+
+				CaptureMainThreadState();
+
+				// Before the setting is first read, so a 1.0.0 project keeps its switch.
+				GeneratedCodeDumpMigration.Run();
+
+				// Subscribed always and checked per compile, so switching the setting applies to the very next
+				// compile rather than after the one that reloads the domain.
+				CompilationPipeline.compilationStarted += OnCompilationStarted;
+				CompilationPipeline.assemblyCompilationFinished += OnAssemblyCompilationFinished;
+				CompilationPipeline.compilationFinished += OnCompilationFinished;
+				AssemblyReloadEvents.beforeAssemblyReload += Shutdown;
+				EditorApplication.quitting += Shutdown;
+
+				if (!_isBatchMode)
+					GeneratedCodeDumpSettingsWatcher.Start(DumpIfJustEnabled);
+
+				DumpIfJustEnabled();
+
+				// Jobs left by the previous domain, or by an Editor that quit mid-dump.
+				if (HasJobs())
+					Kick();
+			}
+			catch (Exception exception)
+			{
+				MarkUnavailable(exception.Message);
+			}
+		}
+
+		/// <summary>
+		/// Dumps everything when the dump has just turned on — Editor start, or the setting switched on in
+		/// Preferences, the menu or its file — or when its output folder is missing, so the folder is never
+		/// stale or absent while the dump is on. Turning it off drops the jobs that have not started. Safe on
+		/// any thread.
+		/// </summary>
+		internal static void DumpIfJustEnabled()
+		{
+			try
+			{
+				lock (SessionLock)
+				{
+					var marker = GeneratedCodeDumpPaths.ToFullPath(GeneratedCodeDumpPaths.SessionMarkerFile);
+					var markerText = GeneratedCodeDumpFiles.ReadTextOrNull(marker);
+
+					var enabled = IsOn();
+					if (!enabled)
+					{
+						if (markerText != null)
+						{
+							GeneratedCodeDumpFiles.TryDeleteFile(marker);
+							DropQueued();
+						}
+
+						return;
+					}
+
+					var markerIsThisProcess = markerText != null
+						&& GeneratedCodeDumpSession.IsMarkerOf(markerText, GeneratedCodeDumpProcess.CurrentId, GeneratedCodeDumpProcess.CurrentStartUtcTicks);
+					var rootExists = Directory.Exists(GeneratedCodeDumpPaths.ToFullPath(GeneratedCodeDumpPaths.Root));
+
+					if (!markerIsThisProcess)
+					{
+						CreateWorkFolder();
+						GeneratedCodeDumpFiles.WriteAtomic(
+							marker,
+							GeneratedCodeDumpSession.FormatMarker(GeneratedCodeDumpProcess.CurrentId, GeneratedCodeDumpProcess.CurrentStartUtcTicks)
+						);
+					}
+
+					if (GeneratedCodeDumpSession.ShouldDumpAll(enabled, markerIsThisProcess, rootExists))
+						DumpAll();
+				}
+			}
+			catch (Exception exception)
+			{
+				MarkUnavailable(exception.Message);
+			}
+		}
+
+		/// <summary>
+		/// Queues every assembly of the newest build graph that loads an analyzer, whatever the setting.
+		/// Returns how many were queued. Safe on any thread.
+		/// </summary>
+		internal static int DumpAll()
+		{
+			try
+			{
+				if (!TryLocateCompiler(out var problem))
+				{
+					Debug.LogWarning(GeneratedCodeDumpIdentity.LogPrefix + problem);
+					return 0;
+				}
+
+				// Created even when nothing is queued, so a project without analyzers does not dump everything
+				// again on every reload.
+				Directory.CreateDirectory(GeneratedCodeDumpPaths.ToFullPath(GeneratedCodeDumpPaths.Root));
+
+				var beeArtifacts = GeneratedCodeDumpPaths.ToFullPath(GeneratedCodeDumpPaths.BeeArtifactsFolder);
+				var queued = Enqueue(GeneratedCodeDumpRsp.ListAssemblies(beeArtifacts));
+				Debug.Log(
+					$"{GeneratedCodeDumpIdentity.LogPrefix}queued {queued} assemblies, at most {MaxConcurrent} compiling at once; "
+					+ $"output in {GeneratedCodeDumpPaths.Root}/"
+				);
+
+				Kick();
+				return queued;
+			}
+			catch (Exception exception)
+			{
+				Debug.LogWarning(GeneratedCodeDumpIdentity.LogPrefix + exception.Message);
+				return 0;
+			}
+		}
+
+		/// <summary>
+		/// Saves the setting and acts on it at once. Main thread (Preferences page and menu).
+		/// </summary>
+		internal static void SetEnabled(bool enabled)
+		{
+			try
+			{
+				GeneratedCodeDumpSettings.Current.Enabled = enabled;
+			}
+			catch (Exception exception)
+			{
+				Debug.LogWarning($"{GeneratedCodeDumpIdentity.LogPrefix}{GeneratedCodeDumpPaths.SettingsFile} could not be written: {exception.Message}");
+				return;
+			}
+
+			DumpIfJustEnabled();
+		}
+
+		/// <summary>
+		/// One round of the finisher: moves the output of every exited replay into the dump, then starts queued
+		/// jobs while fewer than <see cref="MaxConcurrent"/> compilers run.
+		/// </summary>
+		internal static void Tick()
+		{
+			FinishExited();
+			StartQueued();
+		}
+
+		internal static bool HasJobs()
+		{
+			return GeneratedCodeDumpJobs.Any(JobsPath);
+		}
+
+		/// <summary>
+		/// How long batch mode waits for <paramref name="jobs"/> jobs: every job may take the full timeout, and
+		/// <paramref name="maxConcurrent"/> of them run at once.
+		/// </summary>
+		internal static double BatchWaitSeconds(int jobs, int maxConcurrent, double jobTimeoutSeconds)
+		{
+			var rounds = (Math.Max(jobs, 1) + Math.Max(maxConcurrent, 1) - 1) / Math.Max(maxConcurrent, 1);
+			return jobTimeoutSeconds * rounds;
+		}
+
+		private static string JobsPath => GeneratedCodeDumpPaths.ToFullPath(GeneratedCodeDumpPaths.JobsFile);
+
+		private static void CaptureMainThreadState()
+		{
+			_ = GeneratedCodeDumpPaths.ProjectRoot;
+			_ = GeneratedCodeDumpPaths.ScratchRoot;
+			_ = GeneratedCodeDumpSettings.Current;
+			_ = GeneratedCodeDumpProcess.CurrentId;
+			_isBatchMode = Application.isBatchMode;
+
+			var contents = EditorApplication.applicationContentsPath;
+			var dotnetName = Application.platform == RuntimePlatform.WindowsEditor ? "dotnet.exe" : "dotnet";
+			_dotnet = Path.Combine(contents, "NetCoreRuntime", dotnetName);
+			_csc = Path.Combine(contents, "DotNetSdkRoslyn", "csc.dll");
+		}
+
+		private static void OnCompilationStarted(object context)
+		{
+			_compiling = true;
+		}
+
+		private static void OnAssemblyCompilationFinished(string assemblyPath, CompilerMessage[] messages)
+		{
+			try
+			{
+				if (!IsOn())
+					return;
+
+				if (messages != null && messages.Any(message => message.type == CompilerMessageType.Error))
+					return;
+
+				var assembly = Path.GetFileNameWithoutExtension(assemblyPath);
+				if (!string.IsNullOrEmpty(assembly) && !CompiledAssemblies.Contains(assembly))
+					CompiledAssemblies.Add(assembly);
+			}
+			catch (Exception exception)
+			{
+				MarkUnavailable(exception.Message);
+			}
+		}
+
+		private static void OnCompilationFinished(object context)
+		{
+			_compiling = false;
+			if (CompiledAssemblies.Count == 0)
+				return;
+
+			var assemblies = CompiledAssemblies.ToArray();
+			CompiledAssemblies.Clear();
+
+			try
+			{
+				if (!IsOn())
+					return;
+
+				if (!TryLocateCompiler(out var problem))
+				{
+					MarkUnavailable(problem);
+					return;
+				}
+
+				if (Enqueue(assemblies) > 0)
+					Kick();
+			}
+			catch (Exception exception)
+			{
+				MarkUnavailable(exception.Message);
+			}
+		}
+
+		// The finisher first: once it is stopping, a settings callback still running cannot start it again.
+		private static void Shutdown()
+		{
+			GeneratedCodeDumpFinisher.Stop();
+			GeneratedCodeDumpSettingsWatcher.Stop();
+		}
+
+		/// <summary>
+		/// Adds a queued job for each of <paramref name="assemblies"/> whose response file loads an analyzer.
+		/// Returns how many of them now have a job.
+		/// </summary>
+		private static int Enqueue(IEnumerable<string> assemblies)
+		{
+			var beeArtifacts = GeneratedCodeDumpPaths.ToFullPath(GeneratedCodeDumpPaths.BeeArtifactsFolder);
+			var wanted = new List<string>();
+			foreach (var assembly in assemblies.Distinct(StringComparer.Ordinal))
+			{
+				try
+				{
+					var rsp = GeneratedCodeDumpRsp.Find(beeArtifacts, assembly);
+					if (rsp != null && GeneratedCodeDumpArgs.HasAnalyzer(GeneratedCodeDumpRsp.ReadArguments(rsp)))
+						wanted.Add(assembly);
+				}
+				catch (Exception exception) when (exception is IOException || exception is UnauthorizedAccessException)
+				{
+					Debug.LogWarning($"{GeneratedCodeDumpIdentity.LogPrefix}{assembly}: {exception.Message}");
+				}
+			}
+
+			if (wanted.Count == 0)
+				return 0;
+
+			// Created now, not when a replay finishes, so the reload that follows does not find the dump folder
+			// missing and dump everything again.
+			CreateWorkFolder();
+
+			lock (Gate)
+			{
+				var list = GeneratedCodeDumpJobs.Read(JobsPath);
+
+				// Left over by an Editor that quit or crashed mid-dump.
+				if (list.Jobs.Count == 0)
+					CleanScratch(true);
+
+				foreach (var assembly in wanted)
+				{
+					var job = list.Find(assembly);
+					if (job == null)
+						list.Add(assembly);
+					else if (job.State == GeneratedCodeDumpJobState.Running)
+						job.Rerun = true;
+
+					// A queued job reads the response file when it starts, so it covers this request too.
+				}
+
+				GeneratedCodeDumpJobs.Write(JobsPath, list);
+			}
+
+			return wanted.Count;
+		}
+
+		private static void DropQueued()
+		{
+			lock (Gate)
+			{
+				var list = GeneratedCodeDumpJobs.Read(JobsPath);
+				if (list.DropNotStarted())
+					GeneratedCodeDumpJobs.Write(JobsPath, list);
+			}
+		}
+
+		private static void Kick()
+		{
+			if (_isBatchMode)
+				FinishAllBlocking();
+			else
+				GeneratedCodeDumpFinisher.Start();
+		}
+
+		// Once it has given up, it does not wait again in this domain: the leftover jobs are the next session's.
+		private static void FinishAllBlocking()
+		{
+			if (_batchGaveUp)
+				return;
+
+			try
+			{
+				var jobs = GeneratedCodeDumpJobs.Read(JobsPath).Jobs.Count;
+				var budget = BatchWaitSeconds(jobs, MaxConcurrent, JobTimeoutSeconds);
+				var watch = Stopwatch.StartNew();
+				while (HasJobs())
+				{
+					if (watch.Elapsed.TotalSeconds >= budget)
+					{
+						_batchGaveUp = true;
+						Debug.LogWarning($"{GeneratedCodeDumpIdentity.LogPrefix}stopped waiting after {budget:0} s; the rest of the dump finishes in the next Editor session.");
+						return;
+					}
+
+					Tick();
+					if (HasJobs())
+						Thread.Sleep(BatchPollMilliseconds);
+				}
+			}
+			catch (Exception exception)
+			{
+				Debug.LogWarning(GeneratedCodeDumpIdentity.LogPrefix + exception.Message);
+			}
+		}
+
+		private static void StartQueued()
+		{
+			if (_compiling)
+				return;
+
+			lock (Gate)
+			{
+				var list = GeneratedCodeDumpJobs.Read(JobsPath);
+				var queued = list.Jobs.Where(job => job.State == GeneratedCodeDumpJobState.Queued).OrderBy(job => job.Id).ToList();
+				if (queued.Count == 0)
+					return;
+
+				if (!TryLocateCompiler(out var problem))
+				{
+					list.Jobs.RemoveAll(job => job.State == GeneratedCodeDumpJobState.Queued);
+					GeneratedCodeDumpJobs.Write(JobsPath, list);
+					Debug.LogWarning(GeneratedCodeDumpIdentity.LogPrefix + problem);
+					return;
+				}
+
+				var running = list.Jobs.Count(
+					job => job.State == GeneratedCodeDumpJobState.Running && GeneratedCodeDumpProcess.IsRunning(job.ProcessId, job.ProcessStartUtcTicks)
+				);
+
+				foreach (var job in queued)
+				{
+					if (running >= MaxConcurrent || GeneratedCodeDumpFinisher.IsStopping)
+						break;
+
+					try
+					{
+						if (StartReplay(job))
+							running++;
+						else
+							list.Jobs.Remove(job);
+					}
+					catch (Exception exception)
+					{
+						list.Jobs.Remove(job);
+						Debug.LogWarning($"{GeneratedCodeDumpIdentity.LogPrefix}{job.Assembly}: {exception.Message}");
+					}
+
+					// Recorded per job, so a reload right after never starts a second compiler for it.
+					GeneratedCodeDumpJobs.Write(JobsPath, list);
+				}
+			}
+		}
+
+		// False when the assembly has nothing to replay any more.
+		private static bool StartReplay(GeneratedCodeDumpJob job)
+		{
+			var beeArtifacts = GeneratedCodeDumpPaths.ToFullPath(GeneratedCodeDumpPaths.BeeArtifactsFolder);
+			var rsp = GeneratedCodeDumpRsp.Find(beeArtifacts, job.Assembly);
+			if (rsp == null)
+				return false;
+
+			var lines = GeneratedCodeDumpRsp.ReadArguments(rsp);
+			if (!GeneratedCodeDumpArgs.HasAnalyzer(lines))
+				return false;
+
+			// One job per assembly at a time: two would share .work/<Assembly>/, and on Windows the first holds
+			// its files open.
+			var scratch = GeneratedCodeDumpPaths.ScratchDirectory(job.Id);
+			var workDir = GeneratedCodeDumpPaths.WorkDirectory(job.Assembly);
+			GeneratedCodeDumpFiles.DeleteDirectory(workDir);
+			GeneratedCodeDumpFiles.DeleteDirectory(scratch);
+
+			var generatedDir = GeneratedCodeDumpPaths.GeneratedFilesDirectory(job.Id);
+			var outDir = GeneratedCodeDumpPaths.ReplayOutputDirectory(job.Id);
+			CreateWorkFolder();
+			Directory.CreateDirectory(workDir);
+			Directory.CreateDirectory(generatedDir);
+			Directory.CreateDirectory(outDir);
+
+			// csc takes the assembly name from the -out file name, so it stays <Assembly>.dll.
+			var replay = Path.Combine(workDir, GeneratedCodeDumpPaths.ReplayFileName);
+			var arguments = GeneratedCodeDumpArgs.Rewrite(
+				lines,
+				Path.Combine(outDir, job.Assembly + ".dll"),
+				Path.Combine(outDir, job.Assembly + ".ref.dll"),
+				generatedDir,
+				Path.Combine(workDir, GeneratedCodeDumpPaths.ErrorLogFileName)
+			);
+			File.WriteAllLines(replay, arguments, GeneratedCodeDumpFiles.Utf8NoBom);
+
+			// Same switches as Unity's own compile action (Library/Bee/*.dag.json). /noconfig only works on
+			// the command line; inside a response file csc ignores it with CS2023.
+			var startInfo = new ProcessStartInfo
+			{
+				FileName = _dotnet,
+				Arguments = $"exec \"{_csc}\" /nostdlib /noconfig -nologo \"@{replay}\"",
+				WorkingDirectory = GeneratedCodeDumpPaths.ProjectRoot,
+				UseShellExecute = false,
+				CreateNoWindow = true
+			};
+
+			using (var process = Process.Start(startInfo))
+			{
+				if (process == null)
+					throw new InvalidOperationException($"{_dotnet} did not start.");
+
+				job.ProcessId = process.Id;
+				job.ProcessStartUtcTicks = GeneratedCodeDumpProcess.StartUtcTicks(process);
+			}
+
+			job.StartedUtcTicks = DateTime.UtcNow.Ticks;
+			job.State = GeneratedCodeDumpJobState.Running;
+			return true;
+		}
+
+		private static void FinishExited()
+		{
+			var snapshot = GeneratedCodeDumpJobs.Read(JobsPath);
+			var finished = false;
+
+			foreach (var job in snapshot.Jobs.Where(job => job.State == GeneratedCodeDumpJobState.Running))
+			{
+				if (GeneratedCodeDumpFinisher.IsStopping)
+					return;
+
+				try
+				{
+					if (GeneratedCodeDumpProcess.IsRunning(job.ProcessId, job.ProcessStartUtcTicks))
+					{
+						var seconds = (DateTime.UtcNow.Ticks - job.StartedUtcTicks) / (double)TimeSpan.TicksPerSecond;
+						if (seconds < JobTimeoutSeconds)
+							continue;
+
+						GeneratedCodeDumpProcess.TryKill(job.ProcessId, job.ProcessStartUtcTicks);
+						Debug.LogWarning($"{GeneratedCodeDumpIdentity.LogPrefix}{job.Assembly}: the compiler ran for over {JobTimeoutSeconds} s, so it was stopped and its output is ignored.");
+					}
+					else if (!job.Rerun)
+					{
+						SyncOutput(job);
+					}
+				}
+				catch (Exception exception)
+				{
+					Debug.LogWarning($"{GeneratedCodeDumpIdentity.LogPrefix}{job.Assembly}: {exception.Message}");
+				}
+
+				// Last, so a reload before this point just repeats the finish.
+				Complete(job.Id);
+				GeneratedCodeDumpFiles.TryDeleteDirectory(GeneratedCodeDumpPaths.ScratchDirectory(job.Id));
+				finished = true;
+			}
+
+			if (finished)
+				CleanScratch(false);
+		}
+
+		// A job whose generated-files folder is gone counts as done: the previous dump is kept.
+		private static void SyncOutput(GeneratedCodeDumpJob job)
+		{
+			var generatedDir = GeneratedCodeDumpPaths.GeneratedFilesDirectory(job.Id);
+			if (!Directory.Exists(generatedDir))
+				return;
+
+			var workDir = GeneratedCodeDumpPaths.WorkDirectory(job.Assembly);
+			var errorLog = Path.Combine(workDir, GeneratedCodeDumpPaths.ErrorLogFileName);
+			var workFolder = $"{GeneratedCodeDumpPaths.WorkFolder}/{Path.GetFileName(workDir)}/";
+			if (!File.Exists(errorLog))
+			{
+				Debug.LogWarning(
+					$"{GeneratedCodeDumpIdentity.LogPrefix}{job.Assembly}: the compiler stopped before writing {GeneratedCodeDumpPaths.ErrorLogFileName}, so the previous dump is kept. "
+					+ $"Its arguments: {workFolder}{GeneratedCodeDumpPaths.ReplayFileName}"
+				);
+				return;
+			}
+
+			if (SarifError.IsMatch(File.ReadAllText(errorLog)))
+				Debug.LogWarning($"{GeneratedCodeDumpIdentity.LogPrefix}{job.Assembly}: the replay reported compile errors, so the dump can be incomplete. See {workFolder}{GeneratedCodeDumpPaths.ErrorLogFileName}");
+
+			var stamp = new DateTime(job.StartedUtcTicks, DateTimeKind.Utc).ToString(StampFormat, CultureInfo.InvariantCulture);
+			var budget = GeneratedCodeDumpPathBudget.Current;
+			var dumpRoot = GeneratedCodeDumpPaths.ToFullPath(GeneratedCodeDumpPaths.Root);
+			var result = GeneratedCodeDumpOutput.Sync(generatedDir, dumpRoot, job.Assembly, stamp, budget);
+			if (result.TooLong.Count > 0)
+			{
+				Debug.LogWarning(
+					$"{GeneratedCodeDumpIdentity.LogPrefix}{job.Assembly}: {result.TooLong.Count} files skipped: their path is over the {budget.File}-character limit of this OS; "
+					+ $"move the project to a shorter path.\n{string.Join("\n", result.TooLong)}"
+				);
+			}
+
+			if (result.Failed.Count > 0)
+			{
+				Debug.LogWarning(
+					$"{GeneratedCodeDumpIdentity.LogPrefix}{job.Assembly}: {result.Failed.Count} files could not be replaced, most likely open in another program; "
+					+ $"they keep their older 'Dumped:' line and the next dump retries.\n{string.Join("\n", result.Failed)}"
+				);
+			}
+		}
+
+		// Removes a finished job, or queues it again under a new id when a dump was asked meanwhile — also one
+		// asked after FinishExited took its snapshot, since this re-reads the jobs under the gate.
+		private static void Complete(long jobId)
+		{
+			try
+			{
+				lock (Gate)
+				{
+					var list = GeneratedCodeDumpJobs.Read(JobsPath);
+					var job = list.FindById(jobId);
+					if (job == null)
+						return;
+
+					list.Jobs.Remove(job);
+					if (job.Rerun)
+						list.Add(job.Assembly);
+
+					GeneratedCodeDumpJobs.Write(JobsPath, list);
+				}
+			}
+			catch (Exception exception) when (exception is IOException || exception is UnauthorizedAccessException)
+			{
+				Debug.LogWarning($"{GeneratedCodeDumpIdentity.LogPrefix}{GeneratedCodeDumpPaths.JobsFile}: {exception.Message}");
+			}
+		}
+
+		private static void CleanScratch(bool all)
+		{
+			if (all)
+				GeneratedCodeDumpFiles.TryDeleteDirectory(GeneratedCodeDumpPaths.ScratchRoot);
+			else
+				GeneratedCodeDumpFiles.TryDeleteEmptyDirectory(GeneratedCodeDumpPaths.ScratchRoot);
+
+			GeneratedCodeDumpFiles.TryDeleteEmptyDirectory(GeneratedCodeDumpPaths.ScratchBase);
+		}
+
+		// Hidden on Windows, so Open Folder shows only assembly folders. Creates the dump folder too.
+		private static void CreateWorkFolder()
+		{
+			GeneratedCodeDumpFiles.CreateHiddenDirectory(GeneratedCodeDumpPaths.ToFullPath(GeneratedCodeDumpPaths.WorkFolder));
+		}
+
+		private static bool TryLocateCompiler(out string problem)
+		{
+			if (!File.Exists(_dotnet))
+			{
+				problem = $"Unity's .NET runtime was not found at {_dotnet}.";
+				return false;
+			}
+
+			if (!File.Exists(_csc))
+			{
+				problem = $"Unity's C# compiler was not found at {_csc}.";
+				return false;
+			}
+
+			var beeArtifacts = GeneratedCodeDumpPaths.ToFullPath(GeneratedCodeDumpPaths.BeeArtifactsFolder);
+			if (!Directory.Exists(beeArtifacts))
+			{
+				problem = $"Unity's build folder {GeneratedCodeDumpPaths.BeeArtifactsFolder} was not found.";
+				return false;
+			}
+
+			problem = null;
+			return true;
+		}
+
+		private static bool IsOn()
+		{
+			return !_unavailable && GeneratedCodeDumpSettings.IsEnabled;
+		}
+
+		private static void MarkUnavailable(string problem)
+		{
+			if (_unavailable)
+				return;
+
+			_unavailable = true;
+			Debug.LogWarning($"{GeneratedCodeDumpIdentity.LogPrefix}{problem} The dump is off until the next domain reload.");
+		}
+	}
+}

package/Editor/GeneratedCodeDumper.cs.meta

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