Improve warning details in log output

Build acceleration works best when all referenced projects produce a reference assembly each. We recently added a message highlighting when this was not the case, but didn't explain which project needed to be modified in order to fix this issue.

This change tracks and logs which projects need updating. The TargetPath is printed for those projects, which will generally also identify the target framework and so is therefore more helpful than just the .csproj file.

Author: drewnoakes

docs/build-acceleration.md

@@ -102,10 +102,12 @@ Looking through the build output with the following points in mind:
 
 - ⛔ If you see:
 
-   > This project has enabled build acceleration, but at least one referenced project does not produce reference assemblies. Ensure all referenced projects, both direct and indirect, have the 'ProduceReferenceAssembly' MSBuild property set to 'true'.
+   > This project has enabled build acceleration, but not all referenced projects produce a reference assembly. Ensure projects producing the following outputs have the 'ProduceReferenceAssembly' MSBuild property set to 'true': '<path1>', '<path2>'.
 
    Then build acceleration will not know whether it is safe to copy a modified output DLL from a referenced project or not. We rely on the use of reference assemblies to convey this information. To address this, ensure all referenced projects have the `ProduceReferenceAssembly` property set to `true`. You may like to add this to your `Directory.Build.props` file alongside the `AccelerateBuildsInVisualStudio` property. Note that projects targeting `net5.0` or later produce reference assemblies by default. Projects that target .NET Standard may require this to be specified manually (see https://github.com/dotnet/project-system/issues/8865).
 
+   This message lists the referenced projects that are not producing a reference assembly. The `TargetPath` of those projects is used, as this can help disambiguate between target frameworks in multi-targeting projects.
+
 - ✅ You should see a section listing items to copy:
 
    ```

src/Microsoft.VisualStudio.ProjectSystem.Managed/ProjectSystem/UpToDate/BuildUpToDateCheck.FileSystemOperationAggregator.cs

@@ -58,14 +58,26 @@ internal sealed class FileSystemOperationAggregator
         public bool? IsAccelerationEnabled { get; internal set; }
 
         /// <summary>
-        /// Gets whether all referenced projects produce reference assemblies or not.
+        /// Gets paths to the target of any projects that do not produce a reference assembly, or
+        /// <see langword="null"/> if none exist.
         /// </summary>
         /// <remarks>
         /// Build acceleration works best when all referenced projects produce reference assemblies.
-        /// This flag allows us to prompt the user when they have enabled build acceleration, but
+        /// This collecting allows us to prompt the user when they have enabled build acceleration, but
         /// they are referencing projects that do not produce reference assemblies.
         /// </remarks>
-        public bool AllReferencesProduceReferenceAssemblies { get; internal set; } = true;
+        public IReadOnlyList<string>? TargetsWithoutReferenceAssemblies => _targetsWithoutReferenceAssemblies;
+
+        private List<string>? _targetsWithoutReferenceAssemblies;
+
+        internal void AddTargetsWithoutReferenceAssemblies(IReadOnlyList<string> targetsWithoutReferenceAssemblies)
+        {
+            if (targetsWithoutReferenceAssemblies is {  Count: > 0 })
+            {
+                _targetsWithoutReferenceAssemblies ??= new();
+                _targetsWithoutReferenceAssemblies.AddRange(targetsWithoutReferenceAssemblies);
+            }
+        }
 
         public BuildAccelerationResult AccelerationResult
         {
@@ -197,7 +209,7 @@ private sealed class ConfiguredFileSystemOperationAggregator
         private readonly FileSystemOperationAggregator _parent;
         private readonly bool? _isBuildAccelerationEnabled;
 
-        public ConfiguredFileSystemOperationAggregator(FileSystemOperationAggregator parent, bool? isBuildAccelerationEnabled, bool referencesProduceReferenceAssemblies)
+        public ConfiguredFileSystemOperationAggregator(FileSystemOperationAggregator parent, bool? isBuildAccelerationEnabled, IReadOnlyList<string>? targetsWithoutReferenceAssemblies)
         {
             _parent = parent;
             _isBuildAccelerationEnabled = isBuildAccelerationEnabled;
@@ -213,9 +225,9 @@ public ConfiguredFileSystemOperationAggregator(FileSystemOperationAggregator par
                 _parent.IsAccelerationEnabled = false;
             }
 
-            if (referencesProduceReferenceAssemblies is false)
+            if (targetsWithoutReferenceAssemblies is not null)
             {
-                _parent.AllReferencesProduceReferenceAssemblies = false;
+                _parent.AddTargetsWithoutReferenceAssemblies(targetsWithoutReferenceAssemblies);
             }
         }
 

src/Microsoft.VisualStudio.ProjectSystem.Managed/ProjectSystem/UpToDate/BuildUpToDateCheck.cs

@@ -1058,7 +1058,7 @@ private async Task<bool> IsUpToDateInternalAsync(
 
                         bool? isBuildAccelerationEnabled = IsBuildAccelerationEnabled(copyInfo.IsComplete, implicitState);
 
-                        var configuredFileSystemOperations = new ConfiguredFileSystemOperationAggregator(fileSystemOperations, isBuildAccelerationEnabled, copyInfo.AllReferencesProduceReferenceAssemblies);
+                        var configuredFileSystemOperations = new ConfiguredFileSystemOperationAggregator(fileSystemOperations, isBuildAccelerationEnabled, copyInfo.TargetsWithoutReferenceAssemblies);
 
                         string outputFullPath = Path.Combine(implicitState.MSBuildProjectDirectory, implicitState.OutputRelativeOrFullPath);
 
@@ -1113,12 +1113,12 @@ private async Task<bool> IsUpToDateInternalAsync(
                         logger.Minimal(nameof(Resources.FUTD_AccelerationCandidate));
                     }
 
-                    if (fileSystemOperations.IsAccelerationEnabled is true && fileSystemOperations.AllReferencesProduceReferenceAssemblies is false)
+                    if (fileSystemOperations.IsAccelerationEnabled is true && fileSystemOperations.TargetsWithoutReferenceAssemblies is { Count: > 0 })
                     {
                         // This project is configured to use build acceleration, but some of its references do not
                         // produce reference assemblies. Log a message to let the user know that they may be able
                         // to improve their build performance by enabling the production of reference assemblies.
-                        logger.Minimal(nameof(Resources.FUTD_NotAllReferencesProduceReferenceAssemblies));
+                        logger.Minimal(nameof(Resources.FUTD_NotAllReferencesProduceReferenceAssemblies_1), string.Join(", ", fileSystemOperations.TargetsWithoutReferenceAssemblies.Select(s => $"'{s}'")));
                     }
 
                     logger.Verbose(nameof(Resources.FUTD_Completed), sw.Elapsed.TotalMilliseconds);

src/Microsoft.VisualStudio.ProjectSystem.Managed/ProjectSystem/UpToDate/CopyItemAggregator.cs

@@ -38,9 +38,9 @@ public CopyItemsResult TryGatherCopyItemsForProject(string targetPath, BuildUpTo
         // results is strictly an improvement over ignoring what results we do have.
         bool isComplete = true;
 
-        // Whether all referenced projects have ProduceReferenceAssembly set to true. The originating project
-        // is not included in this check (targetPath).
-        bool allReferencesProduceReferenceAssemblies = true;
+        // Lazily populated list of referenced projects not having ProduceReferenceAssembly set to true.
+        // The originating project is not included in this check (targetPath).
+        List<string>? referencesNotProducingReferenceAssembly = null;
 
         List<ProjectCopyData>? contributingProjects = null;
 
@@ -67,7 +67,8 @@ public CopyItemsResult TryGatherCopyItemsForProject(string targetPath, BuildUpTo
                 if (!data.ProduceReferenceAssembly && project != targetPath)
                 {
                     // One of the referenced projects does not produce a reference assembly.
-                    allReferencesProduceReferenceAssemblies = false;
+                    referencesNotProducingReferenceAssembly ??= new();
+                    referencesNotProducingReferenceAssembly.Add(data.TargetPath);
                 }
 
                 foreach (string referencedProjectTargetPath in data.ReferencedProjectTargetPaths)
@@ -83,7 +84,7 @@ public CopyItemsResult TryGatherCopyItemsForProject(string targetPath, BuildUpTo
             }
         }
 
-        return new(GenerateCopyItems(), isComplete, allReferencesProduceReferenceAssemblies);
+        return new(GenerateCopyItems(), isComplete, referencesNotProducingReferenceAssembly);
 
         IEnumerable<(string Path, ImmutableArray<CopyItem> CopyItems)> GenerateCopyItems()
         {

src/Microsoft.VisualStudio.ProjectSystem.Managed/ProjectSystem/UpToDate/ICopyItemAggregator.cs

@@ -35,11 +35,14 @@ internal interface ICopyItemAggregator
 /// </summary>
 /// <param name="ItemsByProject">A sequence of items by project, that are reachable from the current project</param>
 /// <param name="IsComplete">Indicates whether we have items from all reachable projects.</param>
-/// <param name="AllReferencesProduceReferenceAssemblies">Indicates whether all referenced projects produce reference assemblies.</param>
+/// <param name="TargetsWithoutReferenceAssemblies">
+///     A list of target paths for projects that do not produce reference assemblies, or <see langword="null"/> if
+///     all reachable projects do in fact produce reference assemblies.
+/// </param>
 internal record struct CopyItemsResult(
     IEnumerable<(string Path, ImmutableArray<CopyItem> CopyItems)> ItemsByProject,
     bool IsComplete,
-    bool AllReferencesProduceReferenceAssemblies);
+    IReadOnlyList<string>? TargetsWithoutReferenceAssemblies);
 
 /// <summary>
 /// Models the set of copy items a project produces, along with some details about the project.

src/Microsoft.VisualStudio.ProjectSystem.Managed/Resources.Designer.cs

@@ -449,8 +449,8 @@ This project was loaded using the wrong project type, likely as a result of rena
     <value>This project appears to be a candidate for build acceleration. To opt in, set the 'AccelerateBuildsInVisualStudio' MSBuild property to 'true'. See https://aka.ms/vs-build-acceleration.</value>
     <comment>Do not translate 'AccelerateBuildsInVisualStudio' or 'true'.</comment>
   </data>
-  <data name="FUTD_NotAllReferencesProduceReferenceAssemblies" xml:space="preserve">
-    <value>This project has enabled build acceleration, but at least one referenced project does not produce reference assemblies. Ensure all referenced projects, both direct and indirect, have the 'ProduceReferenceAssembly' MSBuild property set to 'true'. See https://aka.ms/vs-build-acceleration.</value>
+  <data name="FUTD_NotAllReferencesProduceReferenceAssemblies_1" xml:space="preserve">
+    <value>This project has enabled build acceleration, but not all referenced projects produce a reference assembly. Ensure projects producing the following outputs have the 'ProduceReferenceAssembly' MSBuild property set to 'true': {0}. See https://aka.ms/vs-build-acceleration for more information.</value>
     <comment>Do not translate 'ProduceReferenceAssembly' or 'true'.</comment>
   </data>
   <data name="FUTD_AccelerationDisabledCopyItemsIncomplete" xml:space="preserve">