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

package/Editor/GeneratedCodeDumpPathBudget.cs

@@ -0,0 +1,67 @@
+using System;
+using System.Text;
+
+namespace GeneratedCodeDump.Editor
+{
+	/// <summary>
+	/// How long a dump path may get on one OS: the whole file path, a folder path and one name. Windows
+	/// counts UTF-16 characters (MAX_PATH 260 with the NUL, and 12 fewer for a folder); macOS and Linux count
+	/// UTF-8 bytes (PATH_MAX 1024 on macOS, used for Linux too).
+	/// </summary>
+	/// <remarks>
+	/// Passed in rather than read, so tests can use small budgets. <see cref="Current"/> uses no Unity API,
+	/// so any thread may read it.
+	/// </remarks>
+	internal readonly struct GeneratedCodeDumpPathBudget
+	{
+		internal static readonly GeneratedCodeDumpPathBudget Windows = new GeneratedCodeDumpPathBudget(259, 247, 255, false);
+		internal static readonly GeneratedCodeDumpPathBudget Unix = new GeneratedCodeDumpPathBudget(1023, 1023, 255, true);
+
+		internal static GeneratedCodeDumpPathBudget Current =>
+			Environment.OSVersion.Platform == PlatformID.Win32NT ? Windows : Unix;
+
+		/// <summary>
+		/// Longest full path of a file.
+		/// </summary>
+		internal int File { get; }
+
+		/// <summary>
+		/// Longest full path of a folder.
+		/// </summary>
+		internal int Folder { get; }
+
+		/// <summary>
+		/// Longest single file or folder name.
+		/// </summary>
+		internal int Name { get; }
+
+		/// <summary>
+		/// True when lengths are counted in UTF-8 bytes, false for UTF-16 characters.
+		/// </summary>
+		internal bool Utf8Bytes { get; }
+
+		internal GeneratedCodeDumpPathBudget(int file, int folder, int name, bool utf8Bytes)
+		{
+			File = file;
+			Folder = folder;
+			Name = name;
+			Utf8Bytes = utf8Bytes;
+		}
+
+		internal int Length(string text)
+		{
+			return Utf8Bytes ? Encoding.UTF8.GetByteCount(text) : text.Length;
+		}
+
+		/// <summary>
+		/// True when <paramref name="folder"/> (a full folder path) and <paramref name="fileName"/> in it are
+		/// both within the budget: the folder, the whole path with one separator, and the file name.
+		/// </summary>
+		internal bool Fits(string folder, string fileName)
+		{
+			var folderLength = Length(folder);
+			var nameLength = Length(fileName);
+			return folderLength <= Folder && folderLength + 1 + nameLength <= File && nameLength <= Name;
+		}
+	}
+}

package/Editor/GeneratedCodeDumpPathBudget.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 4c2ac30fe1a34d2fe989e472d2852e67

package/Editor/GeneratedCodeDumpPaths.cs

@@ -0,0 +1,145 @@
+using System.Globalization;
+using System.IO;
+using System.Text;
+using UnityEngine;
+
+namespace GeneratedCodeDump.Editor
+{
+	/// <summary>
+	/// Every path used by the generated-code dump. Constants are relative to the project root.
+	/// </summary>
+	/// <remarks>
+	/// <see cref="ProjectRoot"/> reads <see cref="Application.dataPath"/>, which only works on the main
+	/// thread, so the dumper reads it once from its static constructor and every thread uses the cached value.
+	/// </remarks>
+	internal static class GeneratedCodeDumpPaths
+	{
+		/// <summary>
+		/// The dump: <c>&lt;Root&gt;/&lt;Assembly&gt;/&lt;GeneratorAssembly&gt;/&lt;hint&gt;</c>, next to
+		/// <see cref="WorkFolder"/>.
+		/// </summary>
+		internal const string Root = "Library/" + GeneratedCodeDumpIdentity.LibraryFolderName;
+
+		internal const string WorkFolder = Root + "/.work";
+		internal const string JobsFile = WorkFolder + "/jobs.txt";
+		internal const string SessionMarkerFile = WorkFolder + "/enabled-session";
+
+		/// <summary>
+		/// The per-user switch. UserSettings/ is Unity's per-user folder: it survives deleting Library/, and
+		/// Unity's standard .gitignore ignores it.
+		/// </summary>
+		internal const string SettingsFile = "UserSettings/GeneratedCodeDumpSettings.json";
+
+		/// <summary>
+		/// The package's Library/ folder up to 1.0.0; <see cref="GeneratedCodeDumpMigration"/> removes it.
+		/// </summary>
+		internal const string LegacyRoot = "Library/" + GeneratedCodeDumpIdentity.PackageName;
+
+		internal const string LegacySettingsFile = LegacyRoot + "/Settings.json";
+		internal const string BeeArtifactsFolder = "Library/Bee/artifacts";
+
+		internal const string ReplayFileName = "replay.rsp";
+		internal const string ErrorLogFileName = "errors.sarif";
+
+		private static string _projectRoot;
+		private static string _scratchRoot;
+
+		internal static string ProjectRoot =>
+			_projectRoot ??= Path.GetDirectoryName(Path.GetFullPath(Application.dataPath));
+
+		internal static string ToFullPath(string projectRelativePath)
+		{
+			return Path.GetFullPath(Path.Combine(ProjectRoot, projectRelativePath));
+		}
+
+		/// <summary>
+		/// Work folder of <paramref name="assembly"/>, holding <see cref="ReplayFileName"/> and
+		/// <see cref="ErrorLogFileName"/>.
+		/// </summary>
+		internal static string WorkDirectory(string assembly)
+		{
+			return WorkDirectory(ToFullPath(WorkFolder), assembly, GeneratedCodeDumpPathBudget.Current);
+		}
+
+		/// <summary>
+		/// <c>&lt;workFolder&gt;/&lt;assembly&gt;</c> (made safe) when both its files fit
+		/// <paramref name="budget"/>, else <c>&lt;workFolder&gt;/</c> and the assembly name cut like a dump
+		/// folder. Only counts lengths.
+		/// </summary>
+		internal static string WorkDirectory(string workFolder, string assembly, GeneratedCodeDumpPathBudget budget)
+		{
+			var full = Path.Combine(workFolder, GeneratedCodeDumpNames.SafeSegment(assembly));
+			if (budget.Fits(full, ErrorLogFileName) && budget.Fits(full, ReplayFileName))
+				return full;
+
+			return Path.Combine(workFolder, GeneratedCodeDumpNames.CutFolder(assembly));
+		}
+
+		/// <summary>
+		/// <c>&lt;temp&gt;/GenDump/</c>, shared by every project on this machine.
+		/// </summary>
+		internal static string ScratchBase => Path.Combine(Path.GetTempPath(), GeneratedCodeDumpIdentity.ScratchFolderName);
+
+		/// <summary>
+		/// <c>&lt;temp&gt;/GCDump/</c>, the temp folder up to 1.0.0.
+		/// </summary>
+		internal static string LegacyScratchBase => Path.Combine(Path.GetTempPath(), GeneratedCodeDumpIdentity.LegacyScratchFolderName);
+
+		/// <summary>
+		/// Root of every dump job's compiler output of this project, in the system temp folder:
+		/// <c>&lt;temp&gt;/GenDump/&lt;project hash&gt;/</c>. The compiler nests each generated file two generator
+		/// folders deep and those names can't be cut, so this stays short and independent of where the project
+		/// lives, for Windows' 260-character path limit.
+		/// </summary>
+		internal static string ScratchRoot => _scratchRoot ??= Path.Combine(ScratchBase, ProjectHash);
+
+		/// <summary>
+		/// This project's folder in <see cref="LegacyScratchBase"/>.
+		/// </summary>
+		internal static string LegacyScratchRoot => Path.Combine(LegacyScratchBase, ProjectHash);
+
+		/// <summary>
+		/// Folder of dump job <paramref name="jobId"/>: <see cref="GeneratedFilesDirectory"/> and
+		/// <see cref="ReplayOutputDirectory"/>.
+		/// </summary>
+		internal static string ScratchDirectory(long jobId)
+		{
+			return Path.Combine(ScratchRoot, jobId.ToString(CultureInfo.InvariantCulture));
+		}
+
+		/// <summary>
+		/// The compiler's <c>-generatedfilesout</c> of dump job <paramref name="jobId"/>: nothing but generated files.
+		/// </summary>
+		internal static string GeneratedFilesDirectory(long jobId)
+		{
+			return Path.Combine(ScratchDirectory(jobId), "g");
+		}
+
+		/// <summary>
+		/// The assemblies the replay of dump job <paramref name="jobId"/> compiles, as <c>&lt;Assembly&gt;.dll</c>
+		/// and <c>&lt;Assembly&gt;.ref.dll</c>.
+		/// </summary>
+		internal static string ReplayOutputDirectory(long jobId)
+		{
+			return Path.Combine(ScratchDirectory(jobId), "o");
+		}
+
+		/// <summary>
+		/// 32-bit FNV-1a over the UTF-8 bytes of <paramref name="text"/>: the same on every machine and Unity
+		/// version, unlike a runtime string hash.
+		/// </summary>
+		internal static uint Fnv1a(string text)
+		{
+			var hash = 2166136261u;
+			foreach (var b in Encoding.UTF8.GetBytes(text ?? string.Empty))
+			{
+				hash ^= b;
+				hash *= 16777619u;
+			}
+
+			return hash;
+		}
+
+		private static string ProjectHash => Fnv1a(ProjectRoot).ToString("x8", CultureInfo.InvariantCulture);
+	}
+}

package/Editor/GeneratedCodeDumpPaths.cs.meta

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

package/Editor/GeneratedCodeDumpProcess.cs

@@ -0,0 +1,119 @@
+using System;
+using System.Diagnostics;
+
+namespace GeneratedCodeDump.Editor
+{
+	/// <summary>
+	/// Identifies processes by id and start time, so a process id the system reuses for another program is
+	/// never taken for a dump compiler or for this Editor. No UnityEditor use.
+	/// </summary>
+	internal static class GeneratedCodeDumpProcess
+	{
+		private const long StartToleranceTicks = 2 * TimeSpan.TicksPerSecond;
+
+		private static int _currentId;
+		private static long _currentStartUtcTicks;
+
+		/// <summary>
+		/// This Editor's process id.
+		/// </summary>
+		internal static int CurrentId
+		{
+			get
+			{
+				CaptureCurrent();
+				return _currentId;
+			}
+		}
+
+		/// <summary>
+		/// This Editor's start time in UTC ticks, or 0 when the system does not tell.
+		/// </summary>
+		internal static long CurrentStartUtcTicks
+		{
+			get
+			{
+				CaptureCurrent();
+				return _currentStartUtcTicks;
+			}
+		}
+
+		/// <summary>
+		/// True when two recorded start times belong to the same process; an unknown (0) time matches any.
+		/// </summary>
+		internal static bool SameStart(long startUtcTicks, long otherStartUtcTicks)
+		{
+			return startUtcTicks == 0
+				|| otherStartUtcTicks == 0
+				|| Math.Abs(startUtcTicks - otherStartUtcTicks) < StartToleranceTicks;
+		}
+
+		internal static long StartUtcTicks(Process process)
+		{
+			try
+			{
+				return process.StartTime.ToUniversalTime().Ticks;
+			}
+			catch (Exception)
+			{
+				return 0;
+			}
+		}
+
+		/// <summary>
+		/// True while process <paramref name="processId"/> runs and is the one started at
+		/// <paramref name="startUtcTicks"/>.
+		/// </summary>
+		internal static bool IsRunning(int processId, long startUtcTicks)
+		{
+			if (processId <= 0)
+				return false;
+
+			try
+			{
+				using (var process = Process.GetProcessById(processId))
+					return !process.HasExited && SameStart(StartUtcTicks(process), startUtcTicks);
+			}
+			catch (ArgumentException)
+			{
+				return false;
+			}
+			catch (InvalidOperationException)
+			{
+				return false;
+			}
+		}
+
+		/// <summary>
+		/// Stops process <paramref name="processId"/> if it still runs and is the one started at
+		/// <paramref name="startUtcTicks"/>. Never throws.
+		/// </summary>
+		internal static void TryKill(int processId, long startUtcTicks)
+		{
+			try
+			{
+				using (var process = Process.GetProcessById(processId))
+				{
+					if (!process.HasExited && SameStart(StartUtcTicks(process), startUtcTicks))
+						process.Kill();
+				}
+			}
+			catch (Exception)
+			{
+				// Already gone, or not ours to stop.
+			}
+		}
+
+		private static void CaptureCurrent()
+		{
+			if (_currentId != 0)
+				return;
+
+			using (var process = Process.GetCurrentProcess())
+			{
+				_currentStartUtcTicks = StartUtcTicks(process);
+				_currentId = process.Id;
+			}
+		}
+	}
+}

package/Editor/GeneratedCodeDumpProcess.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 6e7a567222a95b680a01f5f58ed1001c

package/Editor/GeneratedCodeDumpRsp.cs

@@ -0,0 +1,107 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+
+namespace GeneratedCodeDump.Editor
+{
+	/// <summary>
+	/// Locates Unity's compiler response files: <c>Library/Bee/artifacts/&lt;hash&gt;.dag/&lt;Assembly&gt;.rsp</c>.
+	/// Stale build graphs can sit beside the current one, so the newest file wins. No UnityEditor use.
+	/// </summary>
+	internal static class GeneratedCodeDumpRsp
+	{
+		private const string DagPattern = "*.dag";
+		private const string RspExtension = ".rsp";
+		private const string ModuleFrameworkRspExtension = ".mvfrm.rsp";
+
+		/// <summary>
+		/// The newest <c>*.dag/&lt;assembly&gt;.rsp</c>, or null when there is none.
+		/// </summary>
+		internal static string Find(string beeArtifactsDir, string assembly)
+		{
+			if (string.IsNullOrEmpty(assembly) || !Directory.Exists(beeArtifactsDir))
+				return null;
+
+			var fileName = assembly + RspExtension;
+			if (fileName.EndsWith(ModuleFrameworkRspExtension, StringComparison.OrdinalIgnoreCase))
+				return null;
+
+			string newest = null;
+			var newestTime = DateTime.MinValue;
+			foreach (var dag in Directory.GetDirectories(beeArtifactsDir, DagPattern))
+			{
+				var candidate = Path.Combine(dag, fileName);
+				if (!File.Exists(candidate))
+					continue;
+
+				var time = File.GetLastWriteTimeUtc(candidate);
+				if (newest != null && time <= newestTime)
+					continue;
+
+				newest = candidate;
+				newestTime = time;
+			}
+
+			return newest;
+		}
+
+		/// <summary>
+		/// Names of every assembly with a response file in the newest build graph (the one holding the
+		/// newest response file), sorted.
+		/// </summary>
+		internal static List<string> ListAssemblies(string beeArtifactsDir)
+		{
+			if (!Directory.Exists(beeArtifactsDir))
+				return new List<string>();
+
+			string[] newestFiles = null;
+			var newestTime = DateTime.MinValue;
+			foreach (var dag in Directory.GetDirectories(beeArtifactsDir, DagPattern))
+			{
+				var files = RspFiles(dag);
+				if (files.Length == 0)
+					continue;
+
+				var time = files.Max(File.GetLastWriteTimeUtc);
+				if (newestFiles != null && time <= newestTime)
+					continue;
+
+				newestFiles = files;
+				newestTime = time;
+			}
+
+			if (newestFiles == null)
+				return new List<string>();
+
+			return newestFiles
+				.Select(Path.GetFileName)
+				.Select(name => name.Substring(0, name.Length - RspExtension.Length))
+				.OrderBy(name => name, StringComparer.Ordinal)
+				.ToList();
+		}
+
+		/// <summary>
+		/// The arguments of <paramref name="rspPath"/>, one per line, followed by those of its companion
+		/// <c>&lt;Assembly&gt;.rsp2</c> (per-package <c>/pathmap</c>) when there is one: Unity passes both to the
+		/// compiler, in that order.
+		/// </summary>
+		internal static List<string> ReadArguments(string rspPath)
+		{
+			var lines = File.ReadAllLines(rspPath).ToList();
+			var rsp2 = rspPath + "2";
+			if (File.Exists(rsp2))
+				lines.AddRange(File.ReadAllLines(rsp2));
+
+			return lines;
+		}
+
+		private static string[] RspFiles(string dag)
+		{
+			return Directory.GetFiles(dag)
+				.Where(file => file.EndsWith(RspExtension, StringComparison.OrdinalIgnoreCase))
+				.Where(file => !file.EndsWith(ModuleFrameworkRspExtension, StringComparison.OrdinalIgnoreCase))
+				.ToArray();
+		}
+	}
+}

package/Editor/GeneratedCodeDumpRsp.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 30f94ab3cdd3edf7c8cbd63ca01af028

package/Editor/GeneratedCodeDumpSession.cs

@@ -0,0 +1,65 @@
+using System;
+using System.Globalization;
+
+namespace GeneratedCodeDump.Editor
+{
+	/// <summary>
+	/// The session marker, <see cref="GeneratedCodeDumpPaths.SessionMarkerFile"/>: the process id and start
+	/// time of the Editor that last found the dump on. It tells a domain reload, which keeps the process, from
+	/// an Editor start or the setting being switched on, which both call for a full dump. No UnityEditor use.
+	/// </summary>
+	internal static class GeneratedCodeDumpSession
+	{
+		/// <summary>
+		/// Dump every assembly when the dump is on and either this Editor process has not seen it on yet, or
+		/// the dump folder, <see cref="GeneratedCodeDumpPaths.Root"/>, is missing.
+		/// </summary>
+		internal static bool ShouldDumpAll(bool enabled, bool markerIsThisProcess, bool rootExists)
+		{
+			return enabled && (!markerIsThisProcess || !rootExists);
+		}
+
+		internal static string FormatMarker(int processId, long processStartUtcTicks)
+		{
+			return processId.ToString(CultureInfo.InvariantCulture) + " "
+				+ processStartUtcTicks.ToString(CultureInfo.InvariantCulture) + "\n";
+		}
+
+		/// <summary>
+		/// Reads <c>&lt;process id&gt; [&lt;start ticks&gt;]</c>; a missing start time reads as 0 (unknown).
+		/// </summary>
+		internal static bool TryParseMarker(string text, out int processId, out long processStartUtcTicks)
+		{
+			processId = 0;
+			processStartUtcTicks = 0;
+			if (string.IsNullOrEmpty(text))
+				return false;
+
+			var fields = text.Trim().Split(new[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);
+			if (fields.Length == 0 || fields.Length > 2)
+				return false;
+
+			if (!int.TryParse(fields[0], NumberStyles.None, CultureInfo.InvariantCulture, out processId) || processId <= 0)
+				return false;
+
+			if (fields.Length == 2 && !long.TryParse(fields[1], NumberStyles.None, CultureInfo.InvariantCulture, out processStartUtcTicks))
+			{
+				processId = 0;
+				return false;
+			}
+
+			return true;
+		}
+
+		/// <summary>
+		/// True when <paramref name="markerText"/> names the process <paramref name="processId"/> started at
+		/// <paramref name="processStartUtcTicks"/>.
+		/// </summary>
+		internal static bool IsMarkerOf(string markerText, int processId, long processStartUtcTicks)
+		{
+			return TryParseMarker(markerText, out var markerId, out var markerStart)
+				&& markerId == processId
+				&& GeneratedCodeDumpProcess.SameStart(markerStart, processStartUtcTicks);
+		}
+	}
+}

package/Editor/GeneratedCodeDumpSession.cs.meta

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

package/Editor/GeneratedCodeDumpSettings.cs

@@ -0,0 +1,111 @@
+using System;
+using System.IO;
+using UnityEngine;
+
+namespace GeneratedCodeDump.Editor
+{
+	/// <summary>
+	/// Whether the generated-code dump runs for this user in this project, stored as
+	/// <c>{"enabled": true}</c> in <see cref="GeneratedCodeDumpPaths.SettingsFile"/>. Under UserSettings/,
+	/// Unity's per-user folder, so it survives deleting Library/, Unity's standard .gitignore keeps it out of
+	/// version control, and each developer turns it on for themselves. Batch mode on the same machine follows
+	/// it too.
+	/// </summary>
+	/// <remarks>
+	/// Re-read whenever the file's write time or length changes, so an edit made outside the Editor applies
+	/// without a restart. A missing file, or one that is not valid, means off; an invalid one warns once per
+	/// version. Thread-safe: the settings watcher reads it off the main thread.
+	/// </remarks>
+	internal sealed class GeneratedCodeDumpSettings
+	{
+		private static GeneratedCodeDumpSettings _current;
+
+		private readonly object _sync = new object();
+		private readonly string _path;
+		private bool _enabled;
+		private long _readWriteTicks = -1;
+		private long _readLength = -1;
+
+		internal GeneratedCodeDumpSettings(string path)
+		{
+			_path = path;
+		}
+
+		/// <summary>
+		/// The settings of this project, re-created after each domain reload.
+		/// </summary>
+		internal static GeneratedCodeDumpSettings Current =>
+			_current ??= new GeneratedCodeDumpSettings(GeneratedCodeDumpPaths.ToFullPath(GeneratedCodeDumpPaths.SettingsFile));
+
+		internal static bool IsEnabled => Current.Enabled;
+
+		/// <summary>
+		/// Re-reads the file when its write time or length changed since the last read. Setting it saves the
+		/// file atomically, creating its folder.
+		/// </summary>
+		internal bool Enabled
+		{
+			get
+			{
+				lock (_sync)
+				{
+					var file = new FileInfo(_path);
+					var writeTicks = file.Exists ? file.LastWriteTimeUtc.Ticks : 0;
+					var length = file.Exists ? file.Length : 0;
+					if (writeTicks == _readWriteTicks && length == _readLength)
+						return _enabled;
+
+					if (!TryRead(file.Exists, out var enabled))
+						return _enabled;
+
+					_enabled = enabled;
+					_readWriteTicks = writeTicks;
+					_readLength = length;
+					return _enabled;
+				}
+			}
+			set
+			{
+				lock (_sync)
+				{
+					GeneratedCodeDumpFiles.WriteAtomic(_path, GeneratedCodeDumpSettingsFile.Format(value));
+
+					var file = new FileInfo(_path);
+					_enabled = value;
+					_readWriteTicks = file.LastWriteTimeUtc.Ticks;
+					_readLength = file.Length;
+				}
+			}
+		}
+
+		// False while the file cannot be opened, e.g. mid-write by another program: the next check retries.
+		// An invalid file is remembered as off by its version, so it warns once until it changes again.
+		private bool TryRead(bool exists, out bool enabled)
+		{
+			enabled = false;
+			if (!exists)
+				return true;
+
+			string json;
+			try
+			{
+				json = File.ReadAllText(_path);
+			}
+			catch (Exception exception) when (exception is IOException || exception is UnauthorizedAccessException)
+			{
+				return false;
+			}
+
+			if (!GeneratedCodeDumpSettingsFile.TryParse(json, out enabled))
+			{
+				enabled = false;
+				Debug.LogWarning(
+					$"{GeneratedCodeDumpIdentity.LogPrefix}{_path} is not valid: expected {{\"{GeneratedCodeDumpSettingsFile.EnabledKey}\": true}} "
+					+ "or false. The dump is off."
+				);
+			}
+
+			return true;
+		}
+	}
+}

package/Editor/GeneratedCodeDumpSettings.cs.meta

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