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

package/Editor/GeneratedCodeDumpMigration.cs

@@ -0,0 +1,112 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using UnityEngine;
+
+namespace GeneratedCodeDump.Editor
+{
+	/// <summary>
+	/// Moves a project off the 1.0.0 folders: <see cref="GeneratedCodeDumpPaths.LegacySettingsFile"/> becomes
+	/// <see cref="GeneratedCodeDumpPaths.SettingsFile"/> as it is, unless that file already exists; then the rest
+	/// of <see cref="GeneratedCodeDumpPaths.LegacyRoot"/> and this project's old temp folder are deleted.
+	/// </summary>
+	/// <remarks>
+	/// Runs from the dumper's static constructor, before the setting is first read. A step that fails is a
+	/// warning and is retried on the next start; the legacy folder is kept while its setting could not be moved.
+	/// No UnityEditor use.
+	/// </remarks>
+	internal static class GeneratedCodeDumpMigration
+	{
+		/// <summary>
+		/// Whether the legacy setting moves: only when it exists and the new file does not.
+		/// </summary>
+		internal static bool ShouldMoveSettings(bool legacySettingsExists, bool settingsExists)
+		{
+			return legacySettingsExists && !settingsExists;
+		}
+
+		/// <summary>
+		/// Migrates this project. Never throws.
+		/// </summary>
+		internal static void Run()
+		{
+			try
+			{
+				var legacyRoot = GeneratedCodeDumpPaths.ToFullPath(GeneratedCodeDumpPaths.LegacyRoot);
+				var hadLegacyRoot = Directory.Exists(legacyRoot);
+				var problems = Migrate(
+					legacyRoot,
+					GeneratedCodeDumpPaths.ToFullPath(GeneratedCodeDumpPaths.LegacySettingsFile),
+					GeneratedCodeDumpPaths.ToFullPath(GeneratedCodeDumpPaths.SettingsFile),
+					GeneratedCodeDumpPaths.LegacyScratchRoot,
+					GeneratedCodeDumpPaths.LegacyScratchBase
+				);
+
+				foreach (var problem in problems)
+					Debug.LogWarning(GeneratedCodeDumpIdentity.LogPrefix + problem);
+
+				if (hadLegacyRoot && !Directory.Exists(legacyRoot))
+				{
+					Debug.Log(
+						$"{GeneratedCodeDumpIdentity.LogPrefix}{GeneratedCodeDumpPaths.LegacyRoot}/ is replaced by {GeneratedCodeDumpPaths.Root}/ "
+						+ $"and {GeneratedCodeDumpPaths.SettingsFile}, so it was deleted."
+					);
+				}
+			}
+			catch (Exception exception)
+			{
+				Debug.LogWarning($"{GeneratedCodeDumpIdentity.LogPrefix}moving off {GeneratedCodeDumpPaths.LegacyRoot}/ failed: {exception.Message}");
+			}
+		}
+
+		/// <summary>
+		/// Moves <paramref name="legacySettingsFile"/> to <paramref name="settingsFile"/> when
+		/// <see cref="ShouldMoveSettings"/> says so, then deletes <paramref name="legacyRoot"/> and
+		/// <paramref name="legacyScratchRoot"/>, and <paramref name="legacyScratchBase"/> when it is empty. Full
+		/// paths. Returns what failed.
+		/// </summary>
+		internal static List<string> Migrate(string legacyRoot, string legacySettingsFile, string settingsFile, string legacyScratchRoot, string legacyScratchBase)
+		{
+			var problems = new List<string>();
+
+			if (Directory.Exists(legacyRoot) && TryMoveSettings(legacySettingsFile, settingsFile, problems))
+				TryDelete(legacyRoot, problems);
+
+			if (Directory.Exists(legacyScratchRoot))
+				TryDelete(legacyScratchRoot, problems);
+
+			// Other projects on a 1.0.0 dump may still use it.
+			GeneratedCodeDumpFiles.TryDeleteEmptyDirectory(legacyScratchBase);
+			return problems;
+		}
+
+		private static bool TryMoveSettings(string legacySettingsFile, string settingsFile, List<string> problems)
+		{
+			try
+			{
+				var text = GeneratedCodeDumpFiles.ReadTextOrNull(legacySettingsFile);
+				if (ShouldMoveSettings(text != null, File.Exists(settingsFile)))
+					GeneratedCodeDumpFiles.WriteAtomic(settingsFile, text);
+
+				return true;
+			}
+			catch (Exception exception) when (exception is IOException || exception is UnauthorizedAccessException)
+			{
+				problems.Add($"{legacySettingsFile} could not be moved to {settingsFile}: {exception.Message} The next Editor start retries.");
+				return false;
+			}
+		}
+
+		private static void TryDelete(string folder, List<string> problems)
+		{
+			try
+			{
+				GeneratedCodeDumpFiles.DeleteDirectory(folder);
+			}
+			catch (Exception exception) when (exception is IOException || exception is UnauthorizedAccessException)
+			{
+				problems.Add($"the old folder {folder} could not be deleted: {exception.Message} The next Editor start retries.");
+			}
+		}
+	}
+}

package/Editor/GeneratedCodeDumpMigration.cs.meta

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

package/Editor/GeneratedCodeDumpNames.cs

@@ -0,0 +1,104 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+
+namespace GeneratedCodeDump.Editor
+{
+	/// <summary>
+	/// Names in the dump: reserved Windows names made safe, and too-long names cut to
+	/// <c>&lt;start&gt;~&lt;fnv8 of the full name&gt;</c>, so a cut name stays unique and readable.
+	/// </summary>
+	internal static class GeneratedCodeDumpNames
+	{
+		/// <summary>
+		/// Names of this many characters or fewer are never cut.
+		/// </summary>
+		internal const int MaxUncutLength = 25;
+
+		/// <summary>
+		/// Characters a cut folder name keeps from the start of the full name.
+		/// </summary>
+		internal const int CutFolderStart = 16;
+
+		/// <summary>
+		/// Fewest characters a cut file name keeps from the start of the full name.
+		/// </summary>
+		internal const int MinCutFileStart = 8;
+
+		// "~" and 8 hex digits.
+		private const int TagLength = 9;
+
+		// Longest first, so "A.generated.cs" is not split as "A.generated" + ".cs".
+		private static readonly string[] FileSuffixes = { ".generated.cs", ".g.cs" };
+
+		private static readonly HashSet<string> ReservedWindowsNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
+		{
+			"CON", "PRN", "AUX", "NUL",
+			"COM0", "COM1", "COM2", "COM3", "COM4", "COM5", "COM6", "COM7", "COM8", "COM9",
+			"LPT0", "LPT1", "LPT2", "LPT3", "LPT4", "LPT5", "LPT6", "LPT7", "LPT8", "LPT9"
+		};
+
+		/// <summary>
+		/// <c>~&lt;fnv8&gt;</c>: FNV-1a 32 of <paramref name="fullName"/> as 8 lowercase hex digits.
+		/// </summary>
+		internal static string Tag(string fullName)
+		{
+			return "~" + GeneratedCodeDumpPaths.Fnv1a(fullName).ToString("x8", CultureInfo.InvariantCulture);
+		}
+
+		/// <summary>
+		/// The folder name itself when it has at most <see cref="MaxUncutLength"/> characters, else its first
+		/// <see cref="CutFolderStart"/> characters and <see cref="Tag"/>.
+		/// </summary>
+		internal static string CutFolder(string name)
+		{
+			// Cut from the safe name, so a reserved start stays renamed; the tag keeps any other start safe.
+			var safe = SafeSegment(name);
+			return name.Length <= MaxUncutLength ? safe : safe.Substring(0, CutFolderStart) + Tag(name);
+		}
+
+		/// <summary>
+		/// The file name itself when it fits in <paramref name="room"/> characters, else
+		/// <c>&lt;start&gt;~&lt;fnv8&gt;&lt;suffix&gt;</c> exactly <paramref name="room"/> long, keeping the
+		/// <see cref="Suffix"/> whole. Null when fewer than <see cref="MinCutFileStart"/> characters of the start
+		/// would remain.
+		/// </summary>
+		internal static string CutFile(string fileName, int room)
+		{
+			var safe = SafeSegment(fileName);
+			if (safe.Length <= room)
+				return safe;
+
+			var suffix = Suffix(fileName);
+			var start = room - TagLength - suffix.Length;
+			if (start < MinCutFileStart)
+				return null;
+
+			return SafeSegment(safe.Substring(0, start) + Tag(fileName) + suffix);
+		}
+
+		/// <summary>
+		/// The part of a file name a cut keeps: <c>.generated.cs</c>, <c>.g.cs</c>, else the extension.
+		/// </summary>
+		internal static string Suffix(string fileName)
+		{
+			foreach (var suffix in FileSuffixes)
+			{
+				if (fileName.Length > suffix.Length && fileName.EndsWith(suffix, StringComparison.OrdinalIgnoreCase))
+					return fileName.Substring(fileName.Length - suffix.Length);
+			}
+
+			var extension = Path.GetExtension(fileName);
+			return extension.Length < fileName.Length ? extension : string.Empty;
+		}
+
+		// Windows refuses a folder or file named CON, AUX, NUL… whatever follows the name.
+		internal static string SafeSegment(string segment)
+		{
+			var dot = segment.IndexOf('.');
+			var name = dot < 0 ? segment : segment.Substring(0, dot);
+			return ReservedWindowsNames.Contains(name) ? name + "_" + segment.Substring(name.Length) : segment;
+		}
+	}
+}

package/Editor/GeneratedCodeDumpNames.cs.meta

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

package/Editor/GeneratedCodeDumpOutput.cs

@@ -0,0 +1,449 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+
+namespace GeneratedCodeDump.Editor
+{
+	/// <summary>
+	/// One file of the compiler's generated-files output and its dump name before any cut.
+	/// </summary>
+	internal sealed class GeneratedCodeDumpEntry
+	{
+		/// <summary>
+		/// Path under the generated-files output, '/'-separated:
+		/// <c>&lt;GeneratorAssembly&gt;/&lt;GeneratorType&gt;/&lt;hint name&gt;</c>.
+		/// </summary>
+		internal string Source;
+
+		/// <summary>
+		/// The generator's assembly name; null for a file fewer than two folders deep.
+		/// </summary>
+		internal string GeneratorAssembly;
+
+		/// <summary>
+		/// The generator's full type name; null for a file fewer than two folders deep.
+		/// </summary>
+		internal string GeneratorType;
+
+		/// <summary>
+		/// The hint name as the generator gave it; <see cref="Source"/> when no generator is known.
+		/// </summary>
+		internal string Hint;
+
+		/// <summary>
+		/// The generator's folder with its full, safe name; null when no generator is known.
+		/// </summary>
+		internal string GeneratorFolder;
+
+		/// <summary>
+		/// Path under <see cref="GeneratorFolder"/> (else under the assembly folder), '/'-separated and safe.
+		/// Its last part is the file name.
+		/// </summary>
+		internal string Name;
+
+		/// <summary>
+		/// Path under the assembly folder with full names.
+		/// </summary>
+		internal string FullPath => GeneratorFolder == null ? Name : GeneratorFolder + "/" + Name;
+	}
+
+	/// <summary>
+	/// Where one assembly's files go: its folder (full or cut), each file's path in it, and the files that get
+	/// no path.
+	/// </summary>
+	internal sealed class GeneratedCodeDumpLayout
+	{
+		internal string AssemblyFolder;
+
+		/// <summary>
+		/// The assembly folder's other form (full or cut), which a sync removes; null when both are the same.
+		/// </summary>
+		internal string OtherAssemblyFolder;
+
+		/// <summary>
+		/// Every placed file with its '/'-separated path under <see cref="AssemblyFolder"/>, in entry order.
+		/// </summary>
+		internal readonly List<(GeneratedCodeDumpEntry Entry, string Path)> Files = new List<(GeneratedCodeDumpEntry Entry, string Path)>();
+
+		/// <summary>
+		/// Files whose path is over the budget even with every cut.
+		/// </summary>
+		internal readonly List<GeneratedCodeDumpEntry> TooLong = new List<GeneratedCodeDumpEntry>();
+
+		/// <summary>
+		/// Files whose path an earlier file took.
+		/// </summary>
+		internal readonly List<GeneratedCodeDumpEntry> Taken = new List<GeneratedCodeDumpEntry>();
+	}
+
+	/// <summary>
+	/// What a sync could not do, one line per file with its path under the dump root.
+	/// </summary>
+	internal sealed class GeneratedCodeDumpSyncResult
+	{
+		/// <summary>
+		/// Files skipped, or not written or deleted, because their path is over the OS limit.
+		/// </summary>
+		internal readonly List<string> TooLong = new List<string>();
+
+		/// <summary>
+		/// Files that could not be written or deleted, with the reason.
+		/// </summary>
+		internal readonly List<string> Failed = new List<string>();
+	}
+
+	/// <summary>
+	/// Turns the compiler's generated-files output (<c>&lt;GeneratorAssembly&gt;/&lt;GeneratorType&gt;/&lt;hint name&gt;</c>)
+	/// into the dump layout <c>&lt;Assembly&gt;/&lt;GeneratorAssembly&gt;/&lt;hint name&gt;</c>, adds the header
+	/// lines to every file and syncs it into the dump folder. No UnityEditor use.
+	/// </summary>
+	/// <remarks>
+	/// Names stay whole wherever the path fits the OS limit. When one doesn't, the assembly folder is cut first,
+	/// then the generator folder, then the file name (<see cref="GeneratedCodeDumpNames"/>); a file that still
+	/// doesn't fit is skipped. The header keeps the full names, so a grep finds a cut file.
+	/// </remarks>
+	internal static class GeneratedCodeDumpOutput
+	{
+		private static readonly char[] Separators = { '/', '\\' };
+		private static readonly byte[] Utf8Bom = { 0xEF, 0xBB, 0xBF };
+		private static readonly string WorkFolderName = Path.GetFileName(GeneratedCodeDumpPaths.WorkFolder);
+
+		/// <summary>
+		/// One entry per generated file, from its paths relative to the generated-files output, in ordinal order.
+		/// The hint becomes one file name in its generator assembly's folder. When an earlier file took that
+		/// name there, the later one becomes <c>&lt;stem&gt;~&lt;fnv8 of "&lt;GeneratorType&gt;/&lt;hint&gt;"&gt;&lt;suffix&gt;</c>.
+		/// A file fewer than two folders deep keeps its path, every part made safe.
+		/// </summary>
+		internal static List<GeneratedCodeDumpEntry> Entries(IEnumerable<string> sources)
+		{
+			var entries = new List<GeneratedCodeDumpEntry>();
+			var taken = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+
+			foreach (var source in sources.Select(source => source.Replace('\\', '/')).OrderBy(source => source, StringComparer.Ordinal))
+			{
+				var parts = source.Split(Separators, StringSplitOptions.RemoveEmptyEntries);
+				if (parts.Length == 0)
+					continue;
+
+				var entry = new GeneratedCodeDumpEntry { Source = source };
+				if (parts.Length < 3)
+				{
+					entry.Hint = string.Join("/", parts);
+					entry.Name = string.Join("/", parts.Select(GeneratedCodeDumpNames.SafeSegment));
+				}
+				else
+				{
+					entry.GeneratorAssembly = parts[0];
+					entry.GeneratorType = parts[1];
+					entry.Hint = string.Join("/", parts.Skip(2));
+					entry.GeneratorFolder = GeneratedCodeDumpNames.SafeSegment(parts[0]);
+					entry.Name = string.Join("/", parts.Skip(2).Select(GeneratedCodeDumpNames.SafeSegment));
+					if (taken.Contains(entry.FullPath))
+						entry.Name = WithTag(entry.Name, entry.GeneratorType + "/" + entry.Hint);
+				}
+
+				taken.Add(entry.FullPath);
+				entries.Add(entry);
+			}
+
+			return entries;
+		}
+
+		/// <summary>
+		/// Places every entry under <c>&lt;dumpRoot&gt;/&lt;assembly folder&gt;/</c> within <paramref name="budget"/>.
+		/// If any file doesn't fit with full names, the assembly folder is cut for every file; then a generator
+		/// folder is cut for all its files if any of them still doesn't fit; then each file that still doesn't fit
+		/// gets its name cut to the room left, or is skipped as too long. Only counts lengths.
+		/// </summary>
+		internal static GeneratedCodeDumpLayout Plan(IReadOnlyList<GeneratedCodeDumpEntry> entries, string dumpRoot, string assembly, GeneratedCodeDumpPathBudget budget)
+		{
+			var root = dumpRoot.TrimEnd(Separators);
+			var full = GeneratedCodeDumpNames.SafeSegment(assembly);
+			var cut = GeneratedCodeDumpNames.CutFolder(assembly);
+			var assemblyFolder = entries.All(entry => Fits(budget, root + "/" + full, entry.FullPath)) ? full : cut;
+			var layout = new GeneratedCodeDumpLayout
+			{
+				AssemblyFolder = assemblyFolder,
+				OtherAssemblyFolder = full == cut ? null : assemblyFolder == full ? cut : full
+			};
+
+			var assemblyPath = root + "/" + assemblyFolder;
+			var generatorFolders = new Dictionary<string, string>(StringComparer.Ordinal);
+			foreach (var generator in entries.Where(entry => entry.GeneratorAssembly != null).GroupBy(entry => entry.GeneratorAssembly, StringComparer.Ordinal))
+			{
+				var fullFolder = generator.First().GeneratorFolder;
+				generatorFolders[generator.Key] = generator.All(entry => Fits(budget, assemblyPath + "/" + fullFolder, entry.Name))
+					? fullFolder
+					: GeneratedCodeDumpNames.CutFolder(generator.Key);
+			}
+
+			var placed = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+			foreach (var entry in entries)
+			{
+				var generatorFolder = entry.GeneratorAssembly == null ? null : generatorFolders[entry.GeneratorAssembly];
+				var name = FitName(budget, generatorFolder == null ? assemblyPath : assemblyPath + "/" + generatorFolder, entry.Name);
+				if (name == null)
+				{
+					layout.TooLong.Add(entry);
+					continue;
+				}
+
+				// Two cut names can still meet (32-bit hash).
+				var path = generatorFolder == null ? name : generatorFolder + "/" + name;
+				if (placed.Add(path))
+					layout.Files.Add((entry, path));
+				else
+					layout.Taken.Add(entry);
+			}
+
+			return layout;
+		}
+
+		/// <summary>
+		/// The header lines of a dumped file, with full names: <c>Dumped</c>, <c>Assembly</c>,
+		/// <c>Generator: &lt;assembly&gt; / &lt;type&gt;</c> (left out when <paramref name="generatorAssembly"/> is
+		/// null) and <c>Hint</c>.
+		/// </summary>
+		internal static List<string> Header(string stamp, string assembly, string generatorAssembly, string generatorType, string hint)
+		{
+			var header = new List<string> { "Dumped: " + stamp, "Assembly: " + assembly };
+			if (generatorAssembly != null)
+				header.Add($"Generator: {generatorAssembly} / {generatorType}");
+
+			header.Add("Hint: " + hint);
+			return header;
+		}
+
+		/// <summary>
+		/// Adds <paramref name="header"/> to the file's header: inside a <c>// &lt;auto-generated&gt;</c> block,
+		/// after a <c>// &lt;auto-generated/&gt;</c> line, or else as new first lines. Keeps the file's line
+		/// endings.
+		/// </summary>
+		internal static string Stamp(string text, IReadOnlyList<string> header)
+		{
+			var newLine = text.Contains("\r\n") ? "\r\n" : "\n";
+			var lines = text.Split(new[] { newLine }, StringSplitOptions.None).ToList();
+			var headerEnd = Math.Min(lines.Count, 12);
+
+			for (var i = 0; i < headerEnd; i++)
+			{
+				var line = lines[i].Trim();
+				if (line == "// </auto-generated>")
+				{
+					lines.InsertRange(i, header.Select(entry => "//     " + entry));
+					return string.Join(newLine, lines);
+				}
+
+				if (line == "// <auto-generated/>")
+				{
+					lines.InsertRange(i + 1, header.Select(entry => "// " + entry));
+					return string.Join(newLine, lines);
+				}
+			}
+
+			return string.Concat(header.Select(entry => "// " + entry + newLine)) + text;
+		}
+
+		/// <summary>
+		/// Writes every file under <paramref name="generatedFilesOut"/> into
+		/// <c>&lt;dumpRoot&gt;/&lt;assembly folder&gt;/</c> as <see cref="Plan"/> places it, with the header lines,
+		/// then deletes every other file there and the assembly folder's other form. Files are replaced in place,
+		/// so a file another process holds open keeps its older header. The assembly folder is created by the
+		/// first write and removed when it ends up empty, so an assembly without generated files has no folder.
+		/// Every listing, write and delete is tried on its own; never throws for a single file.
+		/// </summary>
+		internal static GeneratedCodeDumpSyncResult Sync(string generatedFilesOut, string dumpRoot, string assembly, string stamp, GeneratedCodeDumpPathBudget budget)
+		{
+			var result = new GeneratedCodeDumpSyncResult();
+			var source = Path.GetFullPath(generatedFilesOut);
+			var root = Path.GetFullPath(dumpRoot);
+
+			// An output that can't be listed keeps the previous dump.
+			var files = new List<string>();
+			if (Directory.Exists(source) && !TryList(source, files, new List<string>(), result, path => path))
+				return result;
+
+			var entries = Entries(files.Select(file => Relative(source, file)));
+			var layout = Plan(entries, root, assembly, budget);
+			if (string.Equals(layout.AssemblyFolder, WorkFolderName, StringComparison.OrdinalIgnoreCase))
+			{
+				result.Failed.Add($"{assembly}: its dump folder would be the {WorkFolderName} folder");
+				return result;
+			}
+
+			result.TooLong.AddRange(layout.TooLong.Select(entry => GeneratedCodeDumpNames.SafeSegment(assembly) + "/" + entry.FullPath));
+			result.Failed.AddRange(layout.Taken.Select(entry => $"{entry.Source}: every dump path for it is taken by another file"));
+
+			var target = Path.Combine(root, layout.AssemblyFolder);
+			var written = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+			foreach (var (entry, path) in layout.Files)
+			{
+				// Also when the write fails, so the previous dump's file stays.
+				written.Add(path);
+				var file = Path.Combine(target, ToOsPath(path));
+				var header = Header(stamp, assembly, entry.GeneratorAssembly, entry.GeneratorType, entry.Hint);
+				TryFileOperation(result, layout.AssemblyFolder + "/" + path, () =>
+				{
+					Directory.CreateDirectory(Path.GetDirectoryName(file));
+					File.WriteAllBytes(file, StampBytes(File.ReadAllBytes(Path.Combine(source, ToOsPath(entry.Source))), header));
+				});
+			}
+
+			Clean(root, layout.AssemblyFolder, written, result);
+			if (layout.OtherAssemblyFolder != null)
+				Clean(root, layout.OtherAssemblyFolder, new HashSet<string>(), result);
+
+			return result;
+		}
+
+		// "<stem>~<fnv8 of fullName><suffix>" in place of the last part of path.
+		private static string WithTag(string path, string fullName)
+		{
+			var slash = path.LastIndexOf('/');
+			var fileName = path.Substring(slash + 1);
+			var suffix = GeneratedCodeDumpNames.Suffix(fileName);
+			return path.Substring(0, slash + 1) + fileName.Substring(0, fileName.Length - suffix.Length) + GeneratedCodeDumpNames.Tag(fullName) + suffix;
+		}
+
+		// True when <folder>/<path> fits; the path's own folders count toward the folder.
+		private static bool Fits(GeneratedCodeDumpPathBudget budget, string folder, string path)
+		{
+			var slash = path.LastIndexOf('/');
+			return slash < 0
+				? budget.Fits(folder, path)
+				: budget.Fits(folder + "/" + path.Substring(0, slash), path.Substring(slash + 1));
+		}
+
+		// The path itself when it fits under folder, else with its file name cut to the room left; null when even
+		// the shortest cut doesn't fit.
+		private static string FitName(GeneratedCodeDumpPathBudget budget, string folder, string path)
+		{
+			if (Fits(budget, folder, path))
+				return path;
+
+			var slash = path.LastIndexOf('/');
+			var fileFolder = slash < 0 ? folder : folder + "/" + path.Substring(0, slash);
+			var fileName = path.Substring(slash + 1);
+			var folderLength = budget.Length(fileFolder);
+			if (folderLength > budget.Folder)
+				return null;
+
+			// CutFile counts characters; a budget in UTF-8 bytes can need a shorter name.
+			var room = Math.Min(budget.File - folderLength - 1, budget.Name);
+			while (true)
+			{
+				var cut = GeneratedCodeDumpNames.CutFile(fileName, room);
+				if (cut == null)
+					return null;
+
+				if (budget.Fits(fileFolder, cut))
+					return path.Substring(0, slash + 1) + cut;
+
+				room = cut.Length - 1;
+			}
+		}
+
+		private static byte[] StampBytes(byte[] bytes, IReadOnlyList<string> header)
+		{
+			var hasBom = bytes.Length >= 3 && bytes[0] == Utf8Bom[0] && bytes[1] == Utf8Bom[1] && bytes[2] == Utf8Bom[2];
+			var offset = hasBom ? Utf8Bom.Length : 0;
+			var text = Encoding.UTF8.GetString(bytes, offset, bytes.Length - offset);
+			var stamped = Encoding.UTF8.GetBytes(Stamp(text, header));
+			return hasBom ? Utf8Bom.Concat(stamped).ToArray() : stamped;
+		}
+
+		// Deletes every file under <root>/<folder> not in keep (paths under that folder), then every folder left
+		// empty, that one included.
+		private static void Clean(string root, string folder, HashSet<string> keep, GeneratedCodeDumpSyncResult result)
+		{
+			var target = Path.Combine(root, folder);
+			if (!Directory.Exists(target))
+				return;
+
+			var files = new List<string>();
+			var folders = new List<string>();
+			TryList(target, files, folders, result, path => folder + "/" + Relative(target, path));
+
+			foreach (var file in files)
+			{
+				var relative = Relative(target, file);
+				if (!keep.Contains(relative))
+					TryFileOperation(result, folder + "/" + relative, () => File.Delete(file));
+			}
+
+			foreach (var directory in folders.OrderByDescending(path => path.Length))
+				TryDeleteIfEmpty(directory);
+
+			TryDeleteIfEmpty(target);
+		}
+
+		// Adds every file and folder under folder, one listing per folder, so a folder that can't be listed
+		// skips only itself. False when folder itself can't be listed.
+		private static bool TryList(string folder, List<string> files, List<string> folders, GeneratedCodeDumpSyncResult result, Func<string, string> display)
+		{
+			string[] here = null;
+			string[] below = null;
+			var listed = TryFileOperation(result, display(folder), () =>
+			{
+				here = Directory.GetFiles(folder);
+				below = Directory.GetDirectories(folder);
+			});
+			if (!listed)
+				return false;
+
+			files.AddRange(here);
+			foreach (var child in below)
+			{
+				folders.Add(child);
+				TryList(child, files, folders, result, display);
+			}
+
+			return true;
+		}
+
+		// A path over the OS limit goes to TooLong, any other file error to Failed.
+		private static bool TryFileOperation(GeneratedCodeDumpSyncResult result, string path, Action operation)
+		{
+			try
+			{
+				operation();
+				return true;
+			}
+			catch (PathTooLongException)
+			{
+				result.TooLong.Add(path);
+			}
+			catch (Exception exception) when (exception is IOException || exception is UnauthorizedAccessException)
+			{
+				result.Failed.Add($"{path}: {exception.Message}");
+			}
+
+			return false;
+		}
+
+		private static void TryDeleteIfEmpty(string directory)
+		{
+			try
+			{
+				if (!Directory.EnumerateFileSystemEntries(directory).Any())
+					Directory.Delete(directory);
+			}
+			catch (Exception exception) when (exception is IOException || exception is UnauthorizedAccessException)
+			{
+				// Held open by another process; the next dump retries.
+			}
+		}
+
+		private static string Relative(string root, string path)
+		{
+			return path.Substring(root.Length).TrimStart(Separators).Replace('\\', '/');
+		}
+
+		private static string ToOsPath(string path)
+		{
+			return path.Replace('/', Path.DirectorySeparatorChar);
+		}
+	}
+}

package/Editor/GeneratedCodeDumpOutput.cs.meta

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