Embed source file from CodeTaskFactory and RoslynCodeTaskFactory in binlog

src/Build.UnitTests/BuildEventArgsSerialization_Tests.cs

@@ -547,6 +547,15 @@ public void RoundtripResponseFileUsedEventArgs()
                 e => e.ResponseFilePath);
         }
 
+        [Fact]
+        public void RoundtripGeneratedFileUsedEventArgs()
+        {
+            var args = new GeneratedFileUsedEventArgs("MSBuild.rsp", "");
+            Roundtrip(args,
+                e => e.FilePath,
+                e => e.Content);
+        }
+
         [Fact]
         public void RoundtripCriticalBuildMessageEventArgs()
         {

src/Build/Logging/BinaryLogger/BinaryLogRecordKind.cs

@@ -39,6 +39,7 @@ public enum BinaryLogRecordKind
         String,
         TaskParameter,
         ResponseFileUsed,
+        GeneratedFileUsed,
         AssemblyLoad,
     }
 }

src/Build/Logging/BinaryLogger/BinaryLogger.cs

@@ -67,14 +67,16 @@ public sealed class BinaryLogger : ILogger
         //   - Making ProjectStartedEventArgs, ProjectEvaluationFinishedEventArgs, AssemblyLoadBuildEventArgs equal
         //     between de/serialization roundtrips.
         //   - Adding serialized events lengths - to support forward compatible reading
+        // version 19:
+        //   - new record kind: GeneratedFileUsedEventArgs
 
         // This should be never changed.
         // The minimum version of the binary log reader that can read log of above version.
         internal const int ForwardCompatibilityMinimalVersion = 18;
 
         // The current version of the binary log representation.
         // Changes with each update of the binary log format.
-        internal const int FileFormatVersion = 18;
+        internal const int FileFormatVersion = 19;
 
         // The minimum version of the binary log reader that can read log of above version.
         // This should be changed only when the binary log format is changed in a way that would prevent it from being
@@ -364,6 +366,11 @@ private void CollectImports(BuildEventArgs e)
             {
                 projectImportsCollector.AddFile(responseFileArgs.ResponseFilePath);
             }
+            else if (e is GeneratedFileUsedEventArgs generatedFileUsedEventArgs && generatedFileUsedEventArgs.FilePath != null)
+            {
+                string fullPath = Path.GetFullPath(generatedFileUsedEventArgs.FilePath);
+                projectImportsCollector.AddFileFromMemory(fullPath, generatedFileUsedEventArgs.Content);
+            }
         }
 
         /// <summary>

src/Build/Logging/BinaryLogger/BuildEventArgsReader.cs

@@ -315,6 +315,7 @@ void HandleError(FormatErrorMessage msgFactory, bool noThrow, ReaderErrorType re
                 BinaryLogRecordKind.TargetSkipped => ReadTargetSkippedEventArgs(),
                 BinaryLogRecordKind.EnvironmentVariableRead => ReadEnvironmentVariableReadEventArgs(),
                 BinaryLogRecordKind.ResponseFileUsed => ReadResponseFileUsedEventArgs(),
+                BinaryLogRecordKind.GeneratedFileUsed => ReadGeneratedFileUsedEventArgs(),
                 BinaryLogRecordKind.PropertyReassignment => ReadPropertyReassignmentEventArgs(),
                 BinaryLogRecordKind.UninitializedPropertyRead => ReadUninitializedPropertyReadEventArgs(),
                 BinaryLogRecordKind.PropertyInitialValueSet => ReadPropertyInitialValueSetEventArgs(),
@@ -1112,6 +1113,23 @@ private BuildEventArgs ReadResponseFileUsedEventArgs()
             return e;
         }
 
+        private BuildEventArgs ReadGeneratedFileUsedEventArgs()
+        {
+            var fields = ReadBuildEventArgsFields();
+
+            string? filePath = ReadDeduplicatedString();
+            string? content = ReadDeduplicatedString();
+
+            if (filePath != null && content != null)
+            {
+                var e = new GeneratedFileUsedEventArgs(filePath, content);
+                SetCommonFields(e, fields);
+                return e;
+            }
+
+            return new GeneratedFileUsedEventArgs();
+        }
+
         private BuildEventArgs ReadPropertyReassignmentEventArgs()
         {
             var fields = ReadBuildEventArgsFields(readImportance: true);

src/Build/Logging/BinaryLogger/BuildEventArgsWriter.cs

@@ -458,6 +458,7 @@ private BinaryLogRecordKind Write(BuildMessageEventArgs e)
             switch (e)
             {
                 case ResponseFileUsedEventArgs responseFileUsed: return Write(responseFileUsed);
+                case GeneratedFileUsedEventArgs generatedFileUsed: return Write(generatedFileUsed);
                 case TaskParameterEventArgs taskParameter: return Write(taskParameter);
                 case ProjectImportedEventArgs projectImported: return Write(projectImported);
                 case TargetSkippedEventArgs targetSkipped: return Write(targetSkipped);
@@ -554,6 +555,13 @@ private BinaryLogRecordKind Write(ResponseFileUsedEventArgs e)
             WriteDeduplicatedString(e.ResponseFilePath);
             return BinaryLogRecordKind.ResponseFileUsed;
         }
+        private BinaryLogRecordKind Write(GeneratedFileUsedEventArgs e)
+        {
+            WriteMessageFields(e);
+            WriteDeduplicatedString(e.FilePath);
+            WriteDeduplicatedString(e.Content);
+            return BinaryLogRecordKind.GeneratedFileUsed;
+        }
         private BinaryLogRecordKind Write(TaskCommandLineEventArgs e)
         {
             WriteMessageFields(e, writeMessage: false, writeImportance: true);

src/Framework/GeneratedFileUsedEventArgs.cs

@@ -0,0 +1,39 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+
+namespace Microsoft.Build.Framework
+{
+    /// <summary>
+    /// Arguments for the generated file used event
+    /// </summary>
+    [Serializable]
+    public class GeneratedFileUsedEventArgs : BuildMessageEventArgs
+    {
+        public GeneratedFileUsedEventArgs()
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="GeneratedFileUsedEventArgs"/> class.
+        /// </summary>
+        /// 
+        public GeneratedFileUsedEventArgs(string filePath, string content)
+            : base("", null, null, MessageImportance.Low)
+        {
+            FilePath = filePath;
+            Content = content;
+        }
+
+        /// <summary>
+        /// The file path relative to the current project.
+        /// </summary>
+        public string? FilePath { set; get; }
+
+        /// <summary>
+        /// The content of the file.
+        /// </summary>
+        public string? Content { set; get; }
+    }
+}

src/MSBuildTaskHost/MSBuildTaskHost.csproj

@@ -67,6 +67,7 @@
     </Compile>
     <Compile Include="..\Framework\AssemblyUtilities.cs" />
     <Compile Include="..\Framework\ResponseFileUsedEventArgs.cs" />
+    <Compile Include="..\Framework\GeneratedFileUsedEventArgs.cs" />
     <Compile Include="..\Shared\BufferedReadStream.cs" />
     <Compile Include="..\Shared\CollectionHelpers.cs" />
     <Compile Include="..\Shared\CopyOnWriteDictionary.cs">

src/Shared/LogMessagePacketBase.cs

@@ -205,6 +205,11 @@ internal enum LoggingEventType : int
         /// Event is <see cref="ExtendedCriticalBuildMessageEventArgs"/>
         /// </summary>
         ExtendedCriticalBuildMessageEvent = 33,
+
+        /// <summary>
+        /// Event is a <see cref="GeneratedFileUsedEventArgs"/>
+        /// </summary>
+        GeneratedFileUsedEvent = 34,
     }
     #endregion
 
@@ -590,6 +595,8 @@ private BuildEventArgs GetBuildEventArgFromId()
                 LoggingEventType.TaskCommandLineEvent => new TaskCommandLineEventArgs(null, null, MessageImportance.Normal),
                 LoggingEventType.EnvironmentVariableReadEvent => new EnvironmentVariableReadEventArgs(),
                 LoggingEventType.ResponseFileUsedEvent => new ResponseFileUsedEventArgs(null),
+                LoggingEventType.GeneratedFileUsedEvent => new GeneratedFileUsedEventArgs(),
+
 #if !TASKHOST // MSBuildTaskHost is targeting Microsoft.Build.Framework.dll 3.5
                 LoggingEventType.AssemblyLoadEvent => new AssemblyLoadBuildEventArgs(),
                 LoggingEventType.TaskParameterEvent => new TaskParameterEventArgs(0, null, null, true, default),
@@ -762,6 +769,10 @@ private LoggingEventType GetLoggingEventId(BuildEventArgs eventArg)
             {
                 return LoggingEventType.ResponseFileUsedEvent;
             }
+            else if (eventType == typeof(GeneratedFileUsedEventArgs))
+            {
+                return LoggingEventType.GeneratedFileUsedEvent;
+            }
             else
             {
                 return LoggingEventType.CustomEvent;
@@ -804,6 +815,9 @@ private void WriteEventToStream(BuildEventArgs buildEvent, LoggingEventType even
                 case LoggingEventType.ResponseFileUsedEvent:
                     WriteResponseFileUsedEventToStream((ResponseFileUsedEventArgs)buildEvent, translator);
                     break;
+                case LoggingEventType.GeneratedFileUsedEvent:
+                    WriteGeneratedFileUsedEventToStream((GeneratedFileUsedEventArgs)buildEvent, translator);
+                    break;
                 case LoggingEventType.TaskCommandLineEvent:
                     WriteTaskCommandLineEventToStream((TaskCommandLineEventArgs)buildEvent, translator);
                     break;
@@ -938,6 +952,23 @@ private void WriteResponseFileUsedEventToStream(ResponseFileUsedEventArgs respon
 #endif
         }
 
+        /// <summary>
+        /// Write a response generated file used log message into the translator
+        /// </summary>
+        private void WriteGeneratedFileUsedEventToStream(GeneratedFileUsedEventArgs generatedFileUsedEventArgs, ITranslator translator)
+        {
+            string filePath = generatedFileUsedEventArgs.FilePath;
+            string content = generatedFileUsedEventArgs.Content;
+
+            translator.Translate(ref filePath);
+            translator.Translate(ref content);
+
+#if !CLR2COMPATIBILITY
+            DateTime timestamp = generatedFileUsedEventArgs.RawTimestamp;
+            translator.Translate(ref timestamp);
+#endif
+        }
+
 #if !TASKHOST && !MSBUILDENTRYPOINTEXE
         private void WriteProjectEvaluationStartedEventToStream(ProjectEvaluationStartedEventArgs args, ITranslator translator)
         {
@@ -1174,6 +1205,7 @@ private BuildEventArgs ReadEventFromStream(LoggingEventType eventType, ITranslat
                 LoggingEventType.BuildErrorEvent => ReadTaskBuildErrorEventFromStream(translator, message, helpKeyword, senderName),
                 LoggingEventType.BuildMessageEvent => ReadBuildMessageEventFromStream(translator, message, helpKeyword, senderName),
                 LoggingEventType.ResponseFileUsedEvent => ReadResponseFileUsedEventFromStream(translator, message, helpKeyword, senderName),
+                LoggingEventType.GeneratedFileUsedEvent => ReadGeneratedFileUsedEventFromStream(translator, message, helpKeyword, senderName),
                 LoggingEventType.BuildWarningEvent => ReadBuildWarningEventFromStream(translator, message, helpKeyword, senderName),
                 LoggingEventType.EnvironmentVariableReadEvent => ReadEnvironmentVariableReadEventFromStream(translator, message, helpKeyword, senderName),
                 _ => null,
@@ -1335,6 +1367,23 @@ private ResponseFileUsedEventArgs ReadResponseFileUsedEventFromStream(ITranslato
             return buildEvent;
         }
 
+        private GeneratedFileUsedEventArgs ReadGeneratedFileUsedEventFromStream(ITranslator translator, string message, string helpKeyword, string senderName)
+        {
+            string filePath = String.Empty;
+            string content = String.Empty;
+            translator.Translate(ref filePath);
+            translator.Translate(ref content);
+            GeneratedFileUsedEventArgs buildEvent = new GeneratedFileUsedEventArgs(filePath, content);
+
+#if !CLR2COMPATIBILITY
+            DateTime timestamp = default;
+            translator.Translate(ref timestamp);
+            buildEvent.RawTimestamp = timestamp;
+#endif
+
+            return buildEvent;
+        }
+
 #if !TASKHOST && !MSBUILDENTRYPOINTEXE
         private ProjectEvaluationStartedEventArgs ReadProjectEvaluationStartedEventFromStream(ITranslator translator)
         {

src/Shared/TaskLoggingHelper.cs

@@ -503,6 +503,21 @@ public void LogMessageFromResources(MessageImportance importance, string message
 #endif
         }
 
+        /// <summary>
+        /// Logs a file generated from the given data.
+        /// </summary>
+        /// <param name="filePath">The file path relative to the currecnt project.</param>
+        /// <param name="content">The content of the file.</param>
+        public void LogIncludeGeneratedFile(string filePath, string content)
+        {
+            ErrorUtilities.VerifyThrowArgumentNull(filePath, nameof(filePath));
+            ErrorUtilities.VerifyThrowArgumentNull(content, nameof(content));
+
+            var e = new GeneratedFileUsedEventArgs(filePath, content);
+
+            BuildEngine.LogMessageEvent(e);
+        }
+
         /// <summary>
         /// Flatten the inner exception message
         /// </summary>