Lift Windows whitespace-path guard from #13573 into standalone change (#13823)

src/Framework.UnitTests/AbsolutePath_Tests.cs

@@ -82,6 +82,38 @@ public void AbsolutePath_NullOrEmptyWithBasePath_ShouldThrowOnEmpty()
             exception.Message.ShouldStartWith("The value cannot be an empty string.");
         }
 
+        [WindowsOnlyTheory]
+        [InlineData(" ")]
+        [InlineData("  ")]
+        [InlineData("\t")]
+        [InlineData(" \t ")]
+        public void AbsolutePath_WhitespaceWithBasePath_ShouldThrowOnWindows(string whitespace)
+        {
+            // Before the multi-threaded migration, Path.GetFullPath(" ") threw ArgumentException on Windows.
+            // The "absolutize-at-boundary" pattern combines the input with a base path first, so without this
+            // guard Path.GetFullPath would silently trim the trailing whitespace and return the base directory,
+            // masking the original error. The constructor explicitly rejects whitespace-only input on Windows.
+            var basePath = GetTestBasePath();
+
+            var exception = Should.Throw<ArgumentException>(() => new AbsolutePath(whitespace, basePath));
+            exception.Message.ShouldContain("Path cannot be null or whitespace on Windows");
+        }
+
+        [UnixOnlyTheory]
+        [InlineData(" ")]
+        [InlineData("  ")]
+        [InlineData("\t")]
+        public void AbsolutePath_WhitespaceWithBasePath_ShouldNotThrowOnUnix(string whitespace)
+        {
+            // Whitespace is a legal filename character on Unix; preserve the historical accepting behavior.
+            var basePath = GetTestBasePath();
+
+            var absolutePath = new AbsolutePath(whitespace, basePath);
+
+            absolutePath.Value.ShouldBe(Path.Combine(basePath.Value, whitespace));
+            absolutePath.OriginalValue.ShouldBe(whitespace);
+        }
+
         [Theory]
         [InlineData("subfolder")]
         [InlineData("deep/nested/path")]

src/Framework/PathHelpers/AbsolutePath.cs

@@ -101,11 +101,26 @@ private static void ValidatePath(string path)
         /// </summary>
         /// <param name="path">The path to combine with the base path.</param>
         /// <param name="basePath">The base path to combine with.</param>
-        /// <exception cref="ArgumentException">Thrown if <paramref name="path"/> is null or empty.</exception>
+        /// <exception cref="ArgumentException">
+        /// Thrown if <paramref name="path"/> is null or empty, or if <paramref name="path"/> is whitespace-only on Windows.
+        /// </exception>
+        /// <remarks>
+        /// On Windows, whitespace-only inputs are rejected to preserve the historical contract of
+        /// <see cref="System.IO.Path.GetFullPath(string)"/>, which threw <see cref="ArgumentException"/> for
+        /// whitespace-only paths. Without this guard the "absolutize-at-boundary" pattern used by multi-threadable
+        /// tasks would silently combine a whitespace input with the project directory (e.g. <c>"C:\\proj\\ "</c>),
+        /// which <see cref="System.IO.Path.GetFullPath(string)"/> then trims back to the project directory, masking
+        /// the original error. On Unix whitespace is a valid filename character and the input is accepted.
+        /// </remarks>
         public AbsolutePath(string path, AbsolutePath basePath)
         {
             ArgumentException.ThrowIfNullOrEmpty(path);
 
+            if (NativeMethods.IsWindows && string.IsNullOrWhiteSpace(path))
+            {
+                throw new ArgumentException(SR.WhitespacePathNotAllowedOnWindows, nameof(path));
+            }
+
             // This function should not throw when path has illegal characters.
             // For .NET Framework, Microsoft.IO.Path.Combine should be used instead of System.IO.Path.Combine to achieve it.
             // For .NET Core, System.IO.Path.Combine already does not throw in this case.

src/Framework/Resources/SR.resx

@@ -153,6 +153,9 @@
   <data name="PathMustBeRooted" xml:space="preserve">
     <value>Path must be rooted.</value>
   </data>
+  <data name="WhitespacePathNotAllowedOnWindows" xml:space="preserve">
+    <value>Path cannot be null or whitespace on Windows.</value>
+  </data>
   <data name="PathTooLong" xml:space="preserve">
     <value>Path: {0} exceeds the OS max path limit. The fully qualified file name must be less than {1} characters.</value>
   </data>

src/Tasks/AddToWin32Manifest.cs

@@ -94,7 +94,7 @@ public string ManifestPath
         {
             if (ApplicationManifest != null)
             {
-                if (string.IsNullOrEmpty(ApplicationManifest.ItemSpec))
+                if (string.IsNullOrWhiteSpace(ApplicationManifest.ItemSpec))
                 {
                     Log.LogErrorWithCodeFromResources(null, ApplicationManifest.ItemSpec, 0, 0, 0, 0, "AddToWin32Manifest.SpecifiedApplicationManifestCanNotBeFound");
                     return null;

src/Tasks/Move.cs

@@ -176,7 +176,7 @@ public override bool Execute()
                         success = false;
                     }
                 }
-                catch (Exception e) when (ExceptionHandling.IsIoRelatedException(e))
+                catch (Exception e) when (ExceptionHandling.IsIoRelatedException(e) || e is ArgumentException)
                 {
                     string lockedFileMessage = LockCheck.GetLockedFileMessage(sourceFile?.OriginalValue ?? sourceSpec);
                     Log.LogErrorWithCodeFromResources("Move.Error", sourceSpec, destinationSpec, e.Message, lockedFileMessage);