Touch up-to-date files to assist incremental builds (#116)

Author: dfederm

src/Common/Caching/LocalCacheStateManager.cs

@@ -87,11 +87,26 @@ internal async Task<List<KeyValuePair<string, ContentHash>>> GetOutOfDateFilesAs
 
         List<KeyValuePair<string, ContentHash>> outOfDateFiles = new(nodeBuildResult.Outputs.Count);
 
+        // When touching files, use the same timestamp for every file to ensure we don't end up with some outputs with slightly different timestamps, which may lead to missed incrementality.
+        DateTime fileTimestamp = DateTime.Now;
+
         foreach (KeyValuePair<string, ContentHash> kvp in nodeBuildResult.Outputs)
         {
             string relativeFilePath = kvp.Key;
             ContentHash contentHash = kvp.Value;
-            if (!IsFileUpToDate(context, depFile, relativeFilePath, contentHash))
+            if (IsFileUpToDate(context, depFile, relativeFilePath, contentHash))
+            {
+                // Avoid touching the reference assembly as incremental build functionality heavily depends on this file not being updated when it does not change.
+                if (string.Equals(relativeFilePath, nodeContext.ReferenceAssemblyRelativePath, StringComparison.OrdinalIgnoreCase))
+                {
+                    continue;
+                }
+
+                // Touch the file to ensure incremental builds understand that the file is up to date
+                string absoluteFilePath = Path.Combine(_repoRoot, relativeFilePath);
+                File.SetLastWriteTime(absoluteFilePath, fileTimestamp);
+            }
+            else
             {
                 outOfDateFiles.Add(kvp);
             }

src/Common/MSBuildCachePluginBase.cs

@@ -293,7 +293,15 @@ private async Task BeginBuildInnerAsync(CacheContext context, PluginLoggerBase l
             nodeDependencies.Add(node, dependencies);
 
             NodeDescriptor nodeDescriptor = _nodeDescriptorFactory.Create(node.ProjectInstance);
-            NodeContext nodeContext = new(Settings.LogDirectory, node.ProjectInstance, dependencies, parserInfo.ProjectFileRelativePath, nodeDescriptor.FilteredGlobalProperties, inputs, targetNames);
+            NodeContext nodeContext = new(
+                Settings.LogDirectory,
+                node.ProjectInstance,
+                dependencies,
+                parserInfo.ProjectFileRelativePath,
+                nodeDescriptor.FilteredGlobalProperties,
+                inputs,
+                parserInfo.ReferenceAssemblyRelativePath,
+                targetNames);
 
             dumpParserInfoTasks.Add(Task.Run(() => DumpParserInfoAsync(logger, nodeContext, parserInfo), cancellationToken));
             _nodeContexts.Add(nodeDescriptor, nodeContext);

src/Common/NodeContext.cs

@@ -12,8 +12,8 @@ namespace Microsoft.MSBuildCache;
 
 public sealed class NodeContext
 {
-    private static readonly byte[] PropertyHashDelimiter = new byte[] { 0x01 };
-    private static readonly byte[] PropertyValueHashDelimiter = new byte[] { 0x02 };
+    private static readonly byte[] PropertyHashDelimiter = [0x01];
+    private static readonly byte[] PropertyValueHashDelimiter = [0x02];
 
     private readonly string _logDirectory;
     private bool _logDirectoryCreated;
@@ -25,6 +25,7 @@ public NodeContext(
         string projectFileRelativePath,
         IReadOnlyDictionary<string, string> filteredGlobalProperties,
         IReadOnlyList<string> inputs,
+        string? referenceAssemblyRelativePath,
         HashSet<string> targetNames)
     {
         Id = GenerateId(projectFileRelativePath, filteredGlobalProperties);
@@ -34,6 +35,7 @@ public NodeContext(
         ProjectFileRelativePath = projectFileRelativePath;
         FilteredGlobalProperties = filteredGlobalProperties;
         Inputs = inputs;
+        ReferenceAssemblyRelativePath = referenceAssemblyRelativePath;
         TargetNames = targetNames;
     }
 
@@ -64,6 +66,8 @@ public string LogDirectory
 
     public IReadOnlyList<string> Inputs { get; }
 
+    public string? ReferenceAssemblyRelativePath { get; }
+
     public HashSet<string> TargetNames { get; }
 
     public DateTime? StartTimeUtc { get; private set; }

src/Common/Parsing/Parser.cs

@@ -1,8 +1,10 @@
 // Copyright (c) Microsoft. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
+using System;
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.IO;
 using System.Linq;
 using Microsoft.Build.Execution;
 using Microsoft.Build.Experimental.ProjectCache;
@@ -12,7 +14,10 @@
 
 namespace Microsoft.MSBuildCache.Parsing;
 
-internal record class ParserInfo(string ProjectFileRelativePath, IReadOnlyList<PredictedInput> Inputs);
+internal record class ParserInfo(
+    string ProjectFileRelativePath,
+    IReadOnlyList<PredictedInput> Inputs,
+    string? ReferenceAssemblyRelativePath);
 
 internal sealed class Parser
 {
@@ -37,7 +42,7 @@ public IReadOnlyDictionary<ProjectGraphNode, ParserInfo> Parse(ProjectGraph grap
                 continue;
             }
 
-            ProjectPredictionCollector predictionCollector = new(node, _repoRoot);
+            ProjectPredictionCollector predictionCollector = new(node);
             predictionCollectorForProjects.Add(node.ProjectInstance, predictionCollector);
         }
 
@@ -53,8 +58,17 @@ public IReadOnlyDictionary<ProjectGraphNode, ParserInfo> Parse(ProjectGraph grap
         var parserInfoForNodes = new Dictionary<ProjectGraphNode, ParserInfo>(predictionCollectorForProjects.Count);
         foreach (KeyValuePair<ProjectInstance, ProjectPredictionCollector> kvp in predictionCollectorForProjects)
         {
+            ProjectInstance projectInstance = kvp.Key;
             ProjectPredictionCollector predictionCollector = kvp.Value;
-            parserInfoForNodes.Add(predictionCollector.Node, predictionCollector.ToParserInfo());
+
+            string projectFilePath = projectInstance.FullPath;
+            string projectFileRelativePath = projectFilePath.MakePathRelativeTo(_repoRoot) ?? throw new InvalidOperationException($"Project \"{projectFilePath}\" is not under the repo root \"{_repoRoot}\"");
+
+            string targetRefPath = projectInstance.GetPropertyValue("TargetRefPath");
+            string? referenceAssemblyPath = !string.IsNullOrEmpty(targetRefPath) ? Path.Combine(projectInstance.Directory, targetRefPath) : null;
+
+            ParserInfo parserInfo = new(projectFileRelativePath, predictionCollector.Inputs, referenceAssemblyPath);
+            parserInfoForNodes.Add(predictionCollector.Node, parserInfo);
         }
 
         return parserInfoForNodes;

src/Common/Parsing/ProjectPredictionCollector.cs

@@ -14,39 +14,35 @@ namespace Microsoft.MSBuildCache.Parsing;
 internal sealed class ProjectPredictionCollector : IProjectPredictionCollector
 {
     private static readonly char[] DirectorySeparatorChars = { Path.DirectorySeparatorChar };
-    private readonly string _repoRoot;
     private readonly string _projectDirectory;
-    private readonly string _projectFileRelativePath;
 
     // A cache of paths (relative or absolute) to their absolute form.
     // This is scoped per build file since the paths are relative to different directories.
     private readonly Dictionary<string, string> _absolutePathFileCache = new(StringComparer.OrdinalIgnoreCase);
 
     private readonly ConcurrentDictionary<string, PredictedInput> _inputs = new(StringComparer.OrdinalIgnoreCase);
 
-    public ProjectPredictionCollector(ProjectGraphNode node, string repoRoot)
+    public ProjectPredictionCollector(ProjectGraphNode node)
     {
         Node = node;
-        _repoRoot = repoRoot;
-
-        string projectFilePath = node.ProjectInstance.FullPath;
-        _projectDirectory = Path.GetDirectoryName(projectFilePath)!;
-
-        _projectFileRelativePath = projectFilePath.MakePathRelativeTo(_repoRoot) ?? throw new ArgumentException($"Project \"{projectFilePath}\" is not under the repo root \"{repoRoot}\"", nameof(node));
+        _projectDirectory = Path.GetDirectoryName(node.ProjectInstance.FullPath)!;
     }
 
     public ProjectGraphNode Node { get; }
 
-    public ParserInfo ToParserInfo()
+    public IReadOnlyList<PredictedInput> Inputs
     {
-        var inputs = new PredictedInput[_inputs.Count];
-        int inputIndex = 0;
-        foreach (KeyValuePair<string, PredictedInput> kvp in _inputs)
+        get
         {
-            inputs[inputIndex++] = kvp.Value;
-        }
+            var inputs = new PredictedInput[_inputs.Count];
+            int inputIndex = 0;
+            foreach (KeyValuePair<string, PredictedInput> kvp in _inputs)
+            {
+                inputs[inputIndex++] = kvp.Value;
+            }
 
-        return new ParserInfo(_projectFileRelativePath, inputs);
+            return inputs;
+        }
     }
 
     public void AddInputFile(string path, ProjectInstance projectInstance, string predictorName)