Perf: Use struct for WorkUnitResult (#12403)

### Context

`TargetEntry.ExecuteTarget()` + `TaskBuilder.ExecuteTask()` allocate a
large number of `WorkUnitResult` objects.

Nearly all of these allocations are a result of aggregating results
across item buckets, as this produces a new `WorkUnitResult` instance on
every single merge. This looks like an easy case for switching to a
struct, given these are already treated as immutable and used as value
containers (apart from 1 diff here).

Overall net ~40MB in this trace (after subtracting the small increase in
types seen below + `TargetResult` + extra lock object).

Before
<img width="1307" height="396" alt="image"
src="https://github.com/user-attachments/assets/199fe6cc-b05f-4310-a17b-01d64ce22ae1"
/>

After
<img width="1319" height="425" alt="image"
src="https://github.com/user-attachments/assets/fa5aa79c-4ff4-4e25-8cb1-34230f942e88"
/>

Author: ccastanedaucf

src/Build/BackEnd/Components/RequestBuilder/TargetEntry.cs

@@ -457,7 +457,6 @@ internal async Task ExecuteTarget(ITaskBuilder taskBuilder, BuildRequestEntry re
 
                     targetLoggingContext = projectLoggingContext.LogTargetBatchStarted(projectFullPath, _target, parentTargetName, _buildReason);
                     bucket.Initialize(targetLoggingContext);
-                    WorkUnitResult bucketResult = null;
                     targetSuccess = false;
 
                     Lookup.Scope entryForInference = null;
@@ -522,7 +521,7 @@ internal async Task ExecuteTarget(ITaskBuilder taskBuilder, BuildRequestEntry re
                                 }
 
                                 // We either have some work to do or at least we need to infer outputs from inputs.
-                                bucketResult = await ProcessBucket(taskBuilder, targetLoggingContext, GetTaskExecutionMode(dependencyResult), lookupForInference, lookupForExecution);
+                                WorkUnitResult bucketResult = await ProcessBucket(taskBuilder, targetLoggingContext, GetTaskExecutionMode(dependencyResult), lookupForInference, lookupForExecution);
 
                                 // Now aggregate the result with the existing known results.  There are four rules, assuming the target was not
                                 // skipped due to being up-to-date:
@@ -553,7 +552,7 @@ internal async Task ExecuteTarget(ITaskBuilder taskBuilder, BuildRequestEntry re
                                 entryForInference = null;
                                 entryForExecution.LeaveScope();
                                 entryForExecution = null;
-                                targetSuccess = (bucketResult?.ResultCode == WorkUnitResultCode.Success);
+                                targetSuccess = bucketResult.ResultCode == WorkUnitResultCode.Success;
                                 break;
 
                             case DependencyAnalysisResult.SkipNoInputs:
@@ -784,7 +783,7 @@ internal void MarkForStop()
             ErrorUtilities.VerifyThrow(_targetResult.ResultCode == TargetResultCode.Skipped, "ResultCode must be Skipped. ResultCode is {0}.", _state);
             ErrorUtilities.VerifyThrow(_targetResult.WorkUnitResult.ActionCode == WorkUnitActionCode.Continue, "ActionCode must be Continue. ActionCode is {0}.", _state);
 
-            _targetResult.WorkUnitResult.ActionCode = WorkUnitActionCode.Stop;
+            _targetResult.WorkUnitResult = new WorkUnitResult(_targetResult.WorkUnitResult.ResultCode, WorkUnitActionCode.Stop, _targetResult.WorkUnitResult.Exception);
         }
 
         /// <summary>

src/Build/BackEnd/Components/RequestBuilder/TaskBuilder.cs

@@ -669,11 +669,7 @@ private async Task<WorkUnitResult> InitializeAndExecuteTask(TaskLoggingContext t
             {
                 // UNDONE: Move this and the task host.
                 taskHost.LoggingContext = taskLoggingContext;
-                WorkUnitResult executionResult = await ExecuteInstantiatedTask(_taskExecutionHost, taskLoggingContext, taskHost, bucket, howToExecuteTask);
-
-                ErrorUtilities.VerifyThrow(executionResult != null, "Unexpected null execution result");
-
-                return executionResult;
+                return await ExecuteInstantiatedTask(_taskExecutionHost, taskLoggingContext, taskHost, bucket, howToExecuteTask);
             }
             finally
             {

src/Build/BackEnd/Shared/TargetResult.cs

@@ -21,6 +21,11 @@ namespace Microsoft.Build.Execution
     /// </summary>
     public class TargetResult : ITargetResult, ITranslatable
     {
+        /// <summary>
+        /// Lock for cache file access.
+        /// </summary>
+        private readonly object _lock = new();
+
         /// <summary>
         /// The result for this target.
         /// </summary>
@@ -100,7 +105,7 @@ public ITaskItem[] Items
             [DebuggerStepThrough]
             get
             {
-                lock (_result)
+                lock (_lock)
                 {
                     if (_items == null)
                     {
@@ -167,6 +172,9 @@ internal WorkUnitResult WorkUnitResult
         {
             [DebuggerStepThrough]
             get => _result;
+
+            [DebuggerStepThrough]
+            set => _result = value;
         }
 
         /// <summary>
@@ -214,7 +222,7 @@ void ITranslatable.Translate(ITranslator translator)
         {
             if (translator.Mode == TranslationDirection.WriteToStream)
             {
-                lock (_result)
+                lock (_lock)
                 {
                     // Should we have cached these items but now want to send them to another node, we need to
                     // ensure they are loaded before doing so.
@@ -271,7 +279,7 @@ internal static string GetCacheDirectory(int configId, string targetToCache)
         /// </summary>
         internal void CacheItems(int configId, string targetName)
         {
-            lock (_result)
+            lock (_lock)
             {
                 if (_items == null)
                 {

src/Build/BackEnd/Shared/WorkUnitResult.cs

@@ -52,27 +52,27 @@ internal enum WorkUnitActionCode
     /// <summary>
     /// A result of executing a target or task.
     /// </summary>
-    internal class WorkUnitResult : ITranslatable
+    internal readonly struct WorkUnitResult : ITranslatable
     {
         /// <summary>
         /// The result.
         /// </summary>
-        private WorkUnitResultCode _resultCode;
+        private readonly WorkUnitResultCode _resultCode;
 
         /// <summary>
         /// The next action to take.
         /// </summary>
-        private WorkUnitActionCode _actionCode;
+        private readonly WorkUnitActionCode _actionCode;
 
         /// <summary>
         /// The exception from the failure, if any.
         /// </summary>
-        private Exception _exception;
+        private readonly Exception _exception;
 
         /// <summary>
         /// Creates a new work result ready for aggregation during batches.
         /// </summary>
-        internal WorkUnitResult()
+        public WorkUnitResult()
         {
             _resultCode = WorkUnitResultCode.Skipped;
             _actionCode = WorkUnitActionCode.Continue;
@@ -94,7 +94,9 @@ internal WorkUnitResult(WorkUnitResultCode resultCode, WorkUnitActionCode action
         /// </summary>
         private WorkUnitResult(ITranslator translator)
         {
-            ((ITranslatable)this).Translate(translator);
+            translator.TranslateEnum(ref _resultCode, (int)_resultCode);
+            translator.TranslateEnum(ref _actionCode, (int)_actionCode);
+            translator.TranslateException(ref _exception);
         }
 
         /// <summary>
@@ -105,11 +107,7 @@ private WorkUnitResult(ITranslator translator)
         /// <summary>
         /// Get the action code.
         /// </summary>
-        internal WorkUnitActionCode ActionCode
-        {
-            get => _actionCode;
-            set => _actionCode = value;
-        }
+        internal WorkUnitActionCode ActionCode => _actionCode;
 
         /// <summary>
         /// Get the exception
@@ -123,9 +121,17 @@ internal WorkUnitActionCode ActionCode
         /// </summary>
         public void Translate(ITranslator translator)
         {
-            translator.TranslateEnum(ref _resultCode, (int)_resultCode);
-            translator.TranslateEnum(ref _actionCode, (int)_actionCode);
-            translator.TranslateException(ref _exception);
+            if (translator.Mode == TranslationDirection.ReadFromStream)
+            {
+                throw new InvalidOperationException("Readonly struct - use the factory method for deserialization.");
+            }
+
+            WorkUnitResultCode resultCode = _resultCode;
+            WorkUnitActionCode actionCode = _actionCode;
+            Exception exception = _exception;
+            translator.TranslateEnum(ref resultCode, (int)_resultCode);
+            translator.TranslateEnum(ref actionCode, (int)_actionCode);
+            translator.TranslateException(ref exception);
         }
 
         #endregion