Fix compatibility issues in manifest task migration

Issue 1 & 3: Absolutize _manifest.SourcePath in GetOutputPath().
GenerateManifestBase.BuildManifest sets _manifest.SourcePath = GetOutputPath(),
which returned the raw OutputManifest.ItemSpec (potentially relative). The
parameterless Manifest.ResolveFiles() derives search paths from SourcePath and
falls back to Directory.GetCurrentDirectory() for non-rooted paths, breaking
multithreaded isolation. Fix: absolutize via TaskEnvironment.GetAbsolutePath().

Issue 2: Guard Path.GetDirectoryName null result in CreateManifestResourceName.
Path.GetDirectoryName returns null for root paths (e.g. 'C:\') and empty strings
on .NET Core. Passing null to Path.Combine throws ArgumentNullException. Add
?? string.Empty to match pre-migration behavior where the exception was caught
by IsIoRelatedException but could be avoided entirely.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: JanProvaznik

src/Tasks.UnitTests/ManifestTaskEnvironmentTests.cs

@@ -3,6 +3,7 @@
 
 using System;
 using System.IO;
+using System.Runtime.Versioning;
 using Microsoft.Build.Framework;
 using Microsoft.Build.Tasks;
 using Microsoft.Build.UnitTests;
@@ -232,5 +233,86 @@ public void CreateManifestResourceName_PathWithSpaces_ShouldWork()
             bool result = task.Execute();
             result.ShouldBeTrue();
         }
+        // Regression test for Issue 1 & 3: GetOutputPath must return absolutized path.
+        // GenerateManifestBase.BuildManifest sets _manifest.SourcePath = GetOutputPath().
+        // If GetOutputPath returns a relative path, the parameterless Manifest.ResolveFiles()
+        // (used e.g. by ResolveNativeReference) falls back to Directory.GetCurrentDirectory()
+        // instead of the project directory, breaking multithreaded isolation.
+        // The fix: absolutize the path in GetOutputPath.
+        [WindowsOnlyFact]
+        [SupportedOSPlatform("windows")]
+        public void GenerateManifestBase_RelativeOutputManifest_WritesToProjectDir()
+        {
+            using var env = TestEnvironment.Create();
+            var folder = env.CreateFolder();
+
+            // Create a dummy entry point file
+            string entryPointPath = Path.Combine(folder.Path, "TestApp.exe");
+            File.WriteAllText(entryPointPath, "dummy");
+
+            // Use a relative OutputManifest path
+            string relativeManifest = "myapp.exe.manifest";
+
+            var engine = new MockEngine(true);
+            var task = new GenerateApplicationManifest
+            {
+                TaskEnvironment = TaskEnvironmentHelper.CreateForTest(),
+                BuildEngine = engine,
+                AssemblyName = "TestApp",
+                AssemblyVersion = "1.0.0.0",
+                ManifestType = "Native",
+                OutputManifest = new TaskItem(relativeManifest),
+            };
+
+            bool result = task.Execute();
+
+            // Task should succeed writing a native manifest (no entry point required)
+            result.ShouldBeTrue("Task should succeed. Log: " + engine.Log);
+
+            // The manifest should exist at the absolutized path
+            string expectedPath = Path.Combine(Directory.GetCurrentDirectory(), relativeManifest);
+            File.Exists(expectedPath).ShouldBeTrue($"Manifest should be written at: {expectedPath}");
+
+            // Cleanup
+            File.Delete(expectedPath);
+
+            // Output property should preserve the original relative path (no contamination)
+            task.OutputManifest.ItemSpec.ShouldBe(relativeManifest);
+        }
+
+        // Regression test for Issue 2: bare filename resource files should not cause
+        // different exception behavior vs pre-migration code.
+        // Path.GetDirectoryName("file.resx") returns "" and Path.Combine("", "file.cs")
+        // returns "file.cs" — GetAbsolutePath("file.cs") should absolutize without error.
+        [Fact]
+        public void CreateManifestResourceName_BareFilename_WithConvention_ShouldNotThrow()
+        {
+            using var env = TestEnvironment.Create();
+            var folder = env.CreateFolder();
+
+            // Create files in the folder
+            var resxPath = Path.Combine(folder.Path, "MyForm.resx");
+            File.WriteAllText(resxPath, "<root></root>");
+            var csPath = Path.Combine(folder.Path, "MyForm.cs");
+            File.WriteAllText(csPath, "namespace Test { class MyForm { } }");
+
+            // Use bare filename (no directory component) — this is the edge case
+            var task = new CreateCSharpManifestResourceName
+            {
+                TaskEnvironment = TaskEnvironmentHelper.CreateForTest(),
+                BuildEngine = new MockEngine(true),
+                ResourceFiles = new ITaskItem[] { new TaskItem("MyForm.resx") },
+                RootNamespace = "Test",
+                UseDependentUponConvention = true,
+            };
+
+            // Should not throw — the convention check calls
+            // GetAbsolutePath(Path.Combine(Path.GetDirectoryName("MyForm.resx"), "MyForm.cs"))
+            // = GetAbsolutePath(Path.Combine("", "MyForm.cs"))
+            // = GetAbsolutePath("MyForm.cs") — should absolutize against project directory
+            bool result = task.Execute();
+            // The task may return true or false depending on whether the file is found
+            // relative to project dir, but it should NOT throw an unhandled exception
+        }
     }
 }

src/Tasks/CreateManifestResourceName.cs

@@ -194,7 +194,8 @@ internal bool Execute(
                             }
                         }
 
-                        AbsolutePath dependentPath = TaskEnvironment.GetAbsolutePath(Path.Combine(Path.GetDirectoryName(fileName), conventionDependentUpon));
+                        string fileDir = Path.GetDirectoryName(fileName) ?? string.Empty;
+                        AbsolutePath dependentPath = TaskEnvironment.GetAbsolutePath(Path.Combine(fileDir, conventionDependentUpon));
                         if (FileSystems.Default.FileExists(dependentPath))
                         {
                             dependentUpon = conventionDependentUpon;
@@ -219,7 +220,7 @@ internal bool Execute(
 
                     if (isDependentOnSourceFile)
                     {
-                        AbsolutePath pathToDependent = TaskEnvironment.GetAbsolutePath(Path.Combine(Path.GetDirectoryName(fileName), dependentUpon));
+                        AbsolutePath pathToDependent = TaskEnvironment.GetAbsolutePath(Path.Combine(Path.GetDirectoryName(fileName) ?? string.Empty, dependentUpon));
                         binaryStream = createFileStream(pathToDependent, FileMode.Open, FileAccess.Read);
                     }
 

src/Tasks/GenerateManifestBase.cs

@@ -418,7 +418,11 @@ private string GetOutputPath()
         {
             if (OutputManifest != null)
             {
-                return OutputManifest.ItemSpec;
+                // Absolutize so that Manifest.SourcePath (set from this value) is always
+                // rooted. The parameterless Manifest.ResolveFiles() derives search paths
+                // from SourcePath and falls back to Directory.GetCurrentDirectory() for
+                // relative paths, which breaks multithreaded isolation.
+                return TaskEnvironment.GetAbsolutePath(OutputManifest.ItemSpec);
             }
             return GetDefaultFileName();
         }