Reduce risk of collision in temp directory creation

.NET's GetTempFileName is somewhat prone to collision,
per dotnet/runtime#73793

We only use to to "reserve" a name for a directory, but
so import the new CreateTempSubdirectoryCore method from
.NET 7 and use that, as it fixes the collision issue
and removes the extra file creation/deletion steps.

This also allows us to tag the temp directories with a
"t4 prefix.

Mono.TextTemplating/Mono.TextTemplating/DirectoryHelper.cs

@@ -0,0 +1,282 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+//
+
+// imported from dotnet/runtime
+// see notes on individual methods
+
+using System;
+using System.Diagnostics;
+using System.IO;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace Mono.TextTemplating;
+
+#nullable enable
+
+static class TempSubdirectoryHelper
+{
+	/// <summary>
+	/// Create e temporary subdirectory in the system temp directory.
+	/// On .NET 7+, calls <see cref="Directory.CreateTempSubdirectory"/>. Otherwise, it uses an implementation based on the one in from .NET 7.
+	/// </summary>
+	public static DirectoryInfo Create (string? prefix = default)
+#if NETCOREAPP7_0_OR_GREATER
+		=> Directory.CreateTempSubdirectory(prefix);
+}
+#else
+	{
+		if (ClassLibsImpl is not null) {
+			return ClassLibsImpl (prefix);
+		}
+
+		if (prefix is string p && p.IndexOfAny (DirectorySeparatorChars) > -1) {
+			throw new ArgumentException ("Prefix may not contain directory separators", nameof (prefix));
+		}
+
+		string path = isWindows ? CreateTempSubdirectoryCoreWindows (prefix) : CreateTempSubdirectoryCoreWindows (prefix);
+		return new DirectoryInfo (path);
+	}
+
+	static readonly Func<string?, DirectoryInfo>? ClassLibsImpl;
+	static readonly bool isWindows = Path.DirectorySeparatorChar == '\\';
+	static readonly char[] DirectorySeparatorChars;
+
+	static TempSubdirectoryHelper ()
+	{
+		if (typeof (Directory).GetMethod ("CreateTempSubdirectory", BindingFlags.Static | BindingFlags.Public) is MethodInfo fxMethod) {
+			ClassLibsImpl = (Func<string?, DirectoryInfo>) fxMethod.CreateDelegate (typeof(Func<string?, DirectoryInfo>));
+		}
+
+		DirectorySeparatorChars = Path.AltDirectorySeparatorChar == Path.DirectorySeparatorChar
+			? new[] { Path.DirectorySeparatorChar }
+			: new[] { Path.DirectorySeparatorChar };
+	}
+
+	// copy of https://github.com/dotnet/runtime/blob/eb6f712d68f75add00f17a144838c1a64a3c3a47/src/libraries/System.Private.CoreLib/src/System/IO/Directory.Unix.cs#L27
+	// modified to remove deps on new/internal framework APIs
+	static unsafe string CreateTempSubdirectoryCoreUnix (string? prefix)
+	{
+		// mkdtemp takes a char* and overwrites the XXXXXX with six characters
+		// that'll result in a unique directory name.
+		string tempPath = Path.GetTempPath ();
+		int tempPathByteCount = Encoding.UTF8.GetByteCount (tempPath);
+		int prefixByteCount = prefix is not null ? Encoding.UTF8.GetByteCount (prefix) : 0;
+		int totalByteCount = tempPathByteCount + prefixByteCount + 6 + 1;
+
+		byte[] path = new byte[totalByteCount];
+		int pos = Encoding.UTF8.GetBytes (tempPath, 0, tempPath.Length, path, 0);
+		if (prefix is not null) {
+			pos += Encoding.UTF8.GetBytes (prefix, 0, prefix.Length, path, pos);
+		}
+		for(int i = 0; i < 6; i++) {
+			path[pos + i] = (byte)'X';
+		}
+		path[pos + 6] = 0;
+
+		// Create the temp directory.
+		fixed (byte* pPath = path) {
+			if (libc_mkdtemp (pPath) is null) {
+				Unix_ThrowIOExceptionForLastError ();
+			}
+		}
+
+		// 'path' is now the name of the directory
+		Debug.Assert (path[path.Length-1] == 0);
+		return Encoding.UTF8.GetString (path, 0, path.Length - 1); // trim off the trailing '\0'
+	}
+
+	[DllImport ("libc", SetLastError = true, EntryPoint = "mkdtemp")]
+	static unsafe extern byte* libc_mkdtemp (byte* path);
+
+	static void Unix_ThrowIOExceptionForLastError ()
+	{
+		var error = Marshal.GetLastWin32Error ();
+		throw new IOException ("error");
+	}
+
+	// copy of https://github.com/dotnet/runtime/blob/eb6f712d68f75add00f17a144838c1a64a3c3a47/src/libraries/System.Private.CoreLib/src/System/IO/Directory.Windows.cs#L16
+	// modified to remove deps on new/internal framework APIs
+	static unsafe string CreateTempSubdirectoryCoreWindows (string? prefix)
+	{
+		StringBuilder builder = new StringBuilder (MaxShortPath);
+		var tempRoot = Path.GetTempPath ();
+		builder.Append (tempRoot);
+
+		// ensure the base TEMP directory exists
+		Directory.CreateDirectory (tempRoot);
+
+		builder.Append (prefix);
+
+		const int RandomFileNameLength = 12; // 12 == 8 + 1 (for period) + 3
+		int initialTempPathLength = builder.Length;
+		builder.EnsureCapacity (initialTempPathLength + RandomFileNameLength);
+
+		// For generating random file names
+		// 8 random bytes provides 12 chars in our encoding for the 8.3 name.
+		const int RandomKeyLength = 8;
+		byte* pKey = stackalloc byte[RandomKeyLength];
+
+		// to avoid an infinite loop, only try as many as GetTempFileNameW will create
+		const int MaxAttempts = ushort.MaxValue;
+		int attempts = 0;
+		while (attempts < MaxAttempts) {
+			builder.Length = initialTempPathLength;
+			builder.Append (Path.GetRandomFileName ());
+			var path = builder.ToString ();
+
+			bool directoryCreated = Kernel32.CreateDirectory (path, null);
+			if (!directoryCreated) {
+				// in the off-chance that the directory already exists, try again
+				int error = Marshal.GetLastWin32Error ();
+				if (error == ERROR_ALREADY_EXISTS) {
+					builder.Length = initialTempPathLength;
+					attempts++;
+					continue;
+				}
+
+				ThrowExceptionForWin32Error (error);
+			}
+
+			return path;
+		}
+
+		throw new IOException (IO_MaxAttemptsReached);
+	}
+
+	static void ThrowExceptionForWin32Error(int error)
+	{
+		// this is not ideal but we don't have access to anything better
+		Marshal.ThrowExceptionForHR (MakeHRFromErrorCode (error));
+	}
+
+	const int MaxShortPath = 260;
+	const int ERROR_ALREADY_EXISTS = 0xB7;
+	const string IO_MaxAttemptsReached = "Reached maximum directory creation attempts";
+
+	// https://github.com/dotnet/runtime/blob/cbc8695ae0c8c2c2d1ac1fc4546d81e0967ef716/src/libraries/Common/src/System/IO/Win32Marshal.cs#L84
+	static int MakeHRFromErrorCode (int errorCode)
+	{
+		// Don't convert it if it is already an HRESULT
+		if ((0xFFFF0000 & errorCode) != 0)
+			return errorCode;
+
+		return unchecked(((int)0x80070000) | errorCode);
+	}
+
+	// https://github.com/dotnet/runtime/blob/cbc8695ae0c8c2c2d1ac1fc4546d81e0967ef716/src/libraries/Common/src/Interop/Windows/Kernel32/Interop.CreateDirectory.cs#L15
+	internal static class Kernel32
+	{
+		[DllImport ("kernel32.dll", EntryPoint = "CreateDirectoryW", SetLastError = true, CharSet = CharSet.Unicode)]
+		[return: MarshalAs (UnmanagedType.Bool)]
+		static unsafe extern bool CreateDirectoryPrivate (
+			string path,
+			SECURITY_ATTRIBUTES* lpSecurityAttributes);
+
+		internal static unsafe bool CreateDirectory (string path, SECURITY_ATTRIBUTES* lpSecurityAttributes)
+		{
+			// We always want to add for CreateDirectory to get around the legacy 248 character limitation
+			path = PathInternal.EnsureExtendedPrefix (path);
+			return CreateDirectoryPrivate (path, lpSecurityAttributes);
+		}
+
+		[StructLayout (LayoutKind.Sequential)]
+		internal struct SECURITY_ATTRIBUTES
+		{
+			internal uint nLength;
+			internal IntPtr lpSecurityDescriptor;
+			internal BOOL bInheritHandle;
+		}
+
+		internal enum BOOL : int
+		{
+			FALSE = 0,
+			TRUE = 1,
+		}
+	}
+
+	// https://github.com/dotnet/runtime/blob/34bec269ff0b02224f318792c02f0254025b43bf/src/libraries/Common/src/System/IO/PathInternal.Windows.cs#L94
+	class PathInternal
+	{
+		internal static string EnsureExtendedPrefix (string path)
+		{
+			if (IsPartiallyQualified (path) || IsDevice (path))
+				return path;
+
+			// Given \\server\share in longpath becomes \\?\UNC\server\share
+			if (path.StartsWith (UncPathPrefix, StringComparison.OrdinalIgnoreCase))
+				return path.Insert (2, UncExtendedPrefixToInsert);
+
+			return ExtendedPathPrefix + path;
+		}
+
+		internal static bool IsPartiallyQualified (string path)
+		{
+			if (path.Length < 2) {
+				// It isn't fixed, it must be relative.  There is no way to specify a fixed
+				// path with one character (or less).
+				return true;
+			}
+
+			if (IsDirectorySeparator (path[0])) {
+				// There is no valid way to specify a relative path with two initial slashes or
+				// \? as ? isn't valid for drive relative paths and \??\ is equivalent to \\?\
+				return !(path[1] == '?' || IsDirectorySeparator (path[1]));
+			}
+
+			// The only way to specify a fixed path that doesn't begin with two slashes
+			// is the drive, colon, slash format- i.e. C:\
+			return !((path.Length >= 3)
+				&& (path[1] == Path.VolumeSeparatorChar)
+				&& IsDirectorySeparator (path[2])
+				// To match old behavior we'll check the drive character for validity as the path is technically
+				// not qualified if you don't have a valid drive. "=:\" is the "=" file's default data stream.
+				&& IsValidDriveChar (path[0]));
+		}
+
+		[MethodImpl (MethodImplOptions.AggressiveInlining)]
+		internal static bool IsDirectorySeparator (char c)
+		{
+			return c == Path.DirectorySeparatorChar || c == Path.AltDirectorySeparatorChar;
+		}
+
+		internal static bool IsValidDriveChar (char value)
+		{
+			return (uint)((value | 0x20) - 'a') <= (uint)('z' - 'a');
+		}
+
+		internal static bool IsDevice (string path)
+		{
+			return IsExtended (path)
+				||
+				(
+					path.Length >= DevicePrefixLength
+					&& IsDirectorySeparator (path[0])
+					&& IsDirectorySeparator (path[1])
+					&& (path[2] == '.' || path[2] == '?')
+					&& IsDirectorySeparator (path[3])
+				);
+		}
+
+		internal static bool IsExtended (string path)
+		{
+			// While paths like "//?/C:/" will work, they're treated the same as "\\.\" paths.
+			// Skipping of normalization will *only* occur if back slashes ('\') are used.
+			return path.Length >= DevicePrefixLength
+				&& path[0] == '\\'
+				&& (path[1] == '\\' || path[1] == '?')
+				&& path[2] == '?'
+				&& path[3] == '\\';
+		}
+
+		internal const string ExtendedPathPrefix = @"\\?\";
+		internal const string UncPathPrefix = @"\\";
+		internal const string UncExtendedPrefixToInsert = @"?\UNC\";
+		internal const string UncExtendedPathPrefix = @"\\?\UNC\";
+		internal const int DevicePrefixLength = 4;
+	}
+}
+#endif

Mono.TextTemplating/Mono.TextTemplating/TemplatingEngine.cs

@@ -306,9 +306,7 @@ CancellationToken token
 			// there are no equivalent for directories, so we create a directory
 			// based on the file name, which *should* be unique as long as the file
 			// exists.
-			var tempFile = Path.GetTempFileName ();
-			var tempFolder = tempFile + "dir";
-			Directory.CreateDirectory (tempFolder);
+			var tempFolder = TempSubdirectoryHelper.Create ("t4-").FullName;
 
 			if (settings.Log != null) {
 				settings.Log.WriteLine ($"Generating code in '{tempFolder}'");
@@ -332,7 +330,7 @@ CancellationToken token
 
 			var result = await compiler.CompileFile (args, settings.Log, token).ConfigureAwait (false);
 
-			var r = new CompilerResults (new TempFileCollection ());
+			var r = new CompilerResults (new TempFileCollection (tempFolder));
 			r.TempFiles.AddFile (sourceFilename, false);
 
 			if (result.ResponseFile != null) {
@@ -370,7 +368,6 @@ CancellationToken token
 				r.TempFiles.Delete ();
 				// we can delete our temporary file after our temporary folder is deleted.
 				Directory.Delete (tempFolder);
-				File.Delete (tempFile);
 			}
 
 			return (r, compiledAssembly);