Migrate SGen task to Task environment API

src/Tasks.UnitTests/SGen_Tests.cs

@@ -2,9 +2,12 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using System.Diagnostics;
 using System.IO;
 using System.Linq;
+using Microsoft.Build.Framework;
 using Microsoft.Build.Tasks;
+using Microsoft.Build.Utilities;
 using Shouldly;
 using Xunit;
 
@@ -273,6 +276,91 @@ public void TestReferencesCommandLine()
 
             Assert.Equal(targetCommandLine, commandLine);
         }
+
+        /// <summary>
+        /// Verifies that GenerateFullPathToTool returns an absolute path (or null)
+        /// when called with a multithreaded TaskEnvironment, validating the
+        /// TaskEnvironment.GetAbsolutePath() integration.
+        /// </summary>
+        [Fact]
+        public void GenerateFullPathToTool_ReturnsAbsolutePathOrNull()
+        {
+            string projectDir = Path.GetTempPath();
+            using var driver = new MultiThreadedTaskEnvironmentDriver(projectDir);
+            var taskEnv = new TaskEnvironment(driver);
+
+            TestableSGen t = new TestableSGen();
+            t.TaskEnvironment = taskEnv;
+            t.BuildEngine = new MockEngine();
+
+            string result = t.CallGenerateFullPathToTool();
+
+            if (result is not null)
+            {
+                Path.IsPathRooted(result).ShouldBeTrue(
+                    $"GenerateFullPathToTool should return an absolute path, got: {result}");
+            }
+        }
+
+        /// <summary>
+        /// Verifies that the GetProcessStartInfo routes through the multithreadable path
+        /// when TaskEnvironment uses MultiThreadedTaskEnvironmentDriver,
+        /// and that the working directory comes from the TaskEnvironment.
+        /// </summary>
+        [Fact]
+        public void GetProcessStartInfo_UsesTaskEnvironmentWorkingDirectory()
+        {
+            string expectedWorkingDir = Path.GetTempPath().TrimEnd(Path.DirectorySeparatorChar);
+            using var driver = new MultiThreadedTaskEnvironmentDriver(expectedWorkingDir);
+            var taskEnv = new TaskEnvironment(driver);
+
+            TestableSGen t = new TestableSGen();
+            t.TaskEnvironment = taskEnv;
+            t.BuildEngine = new MockEngine();
+
+            ProcessStartInfo startInfo = t.CallGetProcessStartInfo(@"C:\test\sgen.exe", "/nologo", null);
+
+            startInfo.WorkingDirectory.ShouldBe(expectedWorkingDir);
+        }
+
+        /// <summary>
+        /// Verifies that BuildAssemblyPath uses TaskEnvironment.GetAbsolutePath
+        /// instead of Path.GetFullPath, by providing a relative path that resolves
+        /// correctly against the TaskEnvironment's project directory.
+        /// </summary>
+        [Fact]
+        public void BuildAssemblyPath_UsesTaskEnvironmentGetAbsolutePath()
+        {
+            using var env = TestEnvironment.Create();
+            string projectDir = env.CreateFolder().Path;
+            string subDir = "output";
+            Directory.CreateDirectory(Path.Combine(projectDir, subDir));
+
+            using var driver = new MultiThreadedTaskEnvironmentDriver(projectDir);
+            var taskEnv = new TaskEnvironment(driver);
+
+            TestableSGen t = new TestableSGen();
+            t.TaskEnvironment = taskEnv;
+            t.BuildEngine = new MockEngine();
+            t.BuildAssemblyPath = subDir; // relative path
+
+            string result = t.BuildAssemblyPath;
+
+            Path.IsPathRooted(result).ShouldBeTrue(
+                "BuildAssemblyPath should return an absolute path resolved via TaskEnvironment");
+            result.ShouldBe(Path.Combine(projectDir, subDir));
+        }
+
+        /// <summary>
+        /// Subclass that exposes protected methods for testing without reflection.
+        /// </summary>
+        private sealed class TestableSGen : SGen
+        {
+            public string CallGenerateFullPathToTool() => GenerateFullPathToTool();
+
+            public ProcessStartInfo CallGetProcessStartInfo(string pathToTool, string commandLineCommands, string responseFileSwitch)
+                => GetProcessStartInfo(pathToTool, commandLineCommands, responseFileSwitch);
+        }
 #endif
     }
 }

src/Tasks/SGen.cs

@@ -68,6 +68,7 @@
     }
 
 #if RUNTIME_TYPE_NETCORE
+    [MSBuildMultiThreadableTask]
     public class SGen : ToolTaskExtension, ISGenTaskContract
     {
 #pragma warning disable format // region formatting is different in net7.0 and net472, and cannot be fixed for both
@@ -138,6 +139,7 @@
     /// <summary>
     /// Genererates a serialization assembly containing XML serializers for the input assembly.
     /// </summary>
+    [MSBuildMultiThreadableTask]
     public class SGen : ToolTaskExtension, ISGenTaskContract
     {
         private string _buildAssemblyPath;
@@ -170,7 +172,10 @@
                 string thisPath;
                 try
                 {
-                    thisPath = Path.GetFullPath(_buildAssemblyPath);
+                    Path.GetFullPath(_buildAssemblyPath);
+                    thisPath = !string.IsNullOrEmpty(_buildAssemblyPath)
+                       ? TaskEnvironment.GetAbsolutePath(_buildAssemblyPath).GetCanonicalForm()
+                       : _buildAssemblyPath;
                 }
                 catch (Exception e) when (ExceptionHandling.IsIoRelatedException(e))
                 {
@@ -255,16 +260,9 @@
             }
         }
 
-        private string SerializationAssemblyPath
-        {
-            get
-            {
-                Debug.Assert(BuildAssemblyPath.Length > 0, "Build assembly path is blank");
-                return Path.Combine(BuildAssemblyPath, SerializationAssemblyName);
-            }
-        }
+        private AbsolutePath SerializationAssemblyPath => new AbsolutePath(Path.Combine(BuildAssemblyPath, SerializationAssemblyName));
 
-        private string AssemblyFullPath => Path.Combine(BuildAssemblyPath, BuildAssemblyName);
+        private AbsolutePath AssemblyFullPathv => new AbsolutePath(Path.Combine(BuildAssemblyPath, BuildAssemblyName));
 
         public string SdkToolsPath
         {
@@ -307,17 +305,21 @@
 
             // If COMPLUS_InstallRoot\COMPLUS_Version are set (the dogfood world), we want to find it there, instead of
             // the SDK, which may or may not be installed. The following will look there.
-            if (!String.IsNullOrEmpty(Environment.GetEnvironmentVariable("COMPLUS_InstallRoot")) || !String.IsNullOrEmpty(Environment.GetEnvironmentVariable("COMPLUS_Version")))
+            if (!String.IsNullOrEmpty(TaskEnvironment.GetEnvironmentVariable("COMPLUS_InstallRoot")) || !String.IsNullOrEmpty(TaskEnvironment.GetEnvironmentVariable("COMPLUS_Version")))
             {
                 pathToTool = ToolLocationHelper.GetPathToDotNetFrameworkFile(ToolExe, TargetDotNetFrameworkVersion.Latest);
             }
 
-            if (String.IsNullOrEmpty(pathToTool) || !FileSystems.Default.FileExists(pathToTool))
+            if (String.IsNullOrEmpty(pathToTool) || !FileSystems.Default.FileExists(TaskEnvironment.GetAbsolutePath(pathToTool)))
             {
-                pathToTool = SdkToolsPathUtility.GeneratePathToTool(SdkToolsPathUtility.FileInfoExists, ProcessorArchitecture.CurrentProcessArchitecture, SdkToolsPath, ToolExe, Log, true);
+                pathToTool = SdkToolsPathUtility.GeneratePathToTool(
+                    f => !string.IsNullOrEmpty(f)
+                    ? SdkToolsPathUtility.FileInfoExists(TaskEnvironment.GetAbsolutePath(f))
+                    : SdkToolsPathUtility.FileInfoExists(f),
+                    ProcessorArchitecture.CurrentProcessArchitecture, SdkToolsPath, ToolExe, Log, true);
             }
 
-            return pathToTool;
+            return string.IsNullOrEmpty(pathToTool) ? pathToTool : TaskEnvironment.GetAbsolutePath(pathToTool).Value;
         }
 
         /// <summary>
@@ -330,7 +332,7 @@
             {
                 foreach (string reference in References)
                 {
-                    if (!FileSystems.Default.FileExists(reference))
+                    if (string.IsNullOrEmpty(reference) || !FileSystems.Default.FileExists(TaskEnvironment.GetAbsolutePath(reference)))
                     {
                         Log.LogErrorWithCodeFromResources("SGen.ResourceNotFound", reference);
                         return false;
@@ -365,11 +367,11 @@
                 {
                     Debug.Assert(ShouldGenerateSerializer, "GenerateCommandLineCommands() should not be called if ShouldGenerateSerializer is true and SerializationAssembly is null.");
 
-                    SerializationAssembly = [new TaskItem(SerializationAssemblyPath)];
+                    SerializationAssembly = [new TaskItem(SerializationAssemblyPath.OriginalValue)];
                 }
 
                 // Add the assembly switch
-                commandLineBuilder.AppendSwitchIfNotNull("/assembly:", AssemblyFullPath);
+                commandLineBuilder.AppendSwitchIfNotNull("/assembly:", AssemblyFullPath.Value);
 
                 commandLineBuilder.AppendWhenTrue("/proxytypes", Bag, "UseProxyTypes");
 
@@ -441,11 +443,11 @@
                 // leave the earlier produced assembly around to be propagated by later processes.
                 catch (UnauthorizedAccessException e)
                 {
-                    Log.LogErrorWithCodeFromResources("SGen.CouldNotDeleteSerializer", SerializationAssemblyPath, e.Message);
+                    Log.LogErrorWithCodeFromResources("SGen.CouldNotDeleteSerializer", SerializationAssemblyPath.OriginalValue, e.Message);
                 }
                 catch (IOException e)
                 {
-                    Log.LogErrorWithCodeFromResources("SGen.CouldNotDeleteSerializer", SerializationAssemblyPath, e.Message);
+                    Log.LogErrorWithCodeFromResources("SGen.CouldNotDeleteSerializer", SerializationAssemblyPath.OriginalValue, e.Message);
                 }
                 // The DirectoryNotFoundException is safely ignorable since that means that there is no
                 // existing serialization assembly.  This would be extremely unlikely anyway because we