Track files to enable clean builds in MSBuild

20 files changed, 284 insertions, 110 deletions

diff --git a/src/WixToolset.Core.Burn/Bind/BindBundleCommand.cs b/src/WixToolset.Core.Burn/Bind/BindBundleCommand.cs
index bd282f54..5dfe935f 100644
--- a/src/WixToolset.Core.Burn/Bind/BindBundleCommand.cs
+++ b/src/WixToolset.Core.Burn/Bind/BindBundleCommand.cs
@@ -101,7 +101,7 @@ namespace WixToolset.Core.Burn
 
         public IEnumerable<IFileTransfer> FileTransfers { get; private set; }
 
-        public IEnumerable<string> ContentFilePaths { get; private set; }
+        public IEnumerable<ITrackedFile> TrackedFiles { get; private set; }
 
         public void Execute()
         {
diff --git a/src/WixToolset.Core.Burn/BundleBackend.cs b/src/WixToolset.Core.Burn/BundleBackend.cs
index 63504df2..96a35b14 100644
--- a/src/WixToolset.Core.Burn/BundleBackend.cs
+++ b/src/WixToolset.Core.Burn/BundleBackend.cs
@@ -24,7 +24,7 @@ namespace WixToolset.Core.Burn
             //command.WixVariableResolver = context.WixVariableResolver;
             command.Execute();
 
-            return new BindResult { FileTransfers = command.FileTransfers, ContentFilePaths = command.ContentFilePaths };
+            return new BindResult { FileTransfers = command.FileTransfers, TrackedFiles = command.TrackedFiles };
         }
 
         public bool Inscribe(IInscribeContext context)
diff --git a/src/WixToolset.Core.WindowsInstaller/Bind/BindDatabaseCommand.cs b/src/WixToolset.Core.WindowsInstaller/Bind/BindDatabaseCommand.cs
index 9194c4c7..a7da13bb 100644
--- a/src/WixToolset.Core.WindowsInstaller/Bind/BindDatabaseCommand.cs
+++ b/src/WixToolset.Core.WindowsInstaller/Bind/BindDatabaseCommand.cs
@@ -39,6 +39,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
             this.FileSystemExtensions = context.FileSystemExtensions;
             this.Intermediate = context.IntermediateRepresentation;
             this.OutputPath = context.OutputPath;
+            this.OutputPdbPath = context.OutputPdbPath;
             this.IntermediateFolder = context.IntermediateFolder;
             this.Validator = validator;
 
@@ -71,6 +72,8 @@ namespace WixToolset.Core.WindowsInstaller.Bind
 
         private string OutputPath { get; }
 
+        private string OutputPdbPath { get; }
+
         private bool SuppressAddingValidationRows { get; }
 
         private bool SuppressLayout { get; }
@@ -83,7 +86,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
 
         public IEnumerable<IFileTransfer> FileTransfers { get; private set; }
 
-        public IEnumerable<string> ContentFilePaths { get; private set; }
+        public IEnumerable<ITrackedFile> TrackedFiles { get; private set; }
 
         public Pdb Pdb { get; private set; }
 
@@ -92,6 +95,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
             var section = this.Intermediate.Sections.Single();
 
             var fileTransfers = new List<IFileTransfer>();
+            var trackedFiles = new List<ITrackedFile>();
 
             var containsMergeModules = false;
             var suppressedTableNames = new HashSet<string>();
@@ -396,6 +400,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                 command.Execute();
 
                 fileTransfers.AddRange(command.FileTransfers);
+                trackedFiles.AddRange(command.TrackedFiles);
             }
 
 #if TODO_FINISH_PATCH
@@ -416,11 +421,12 @@ namespace WixToolset.Core.WindowsInstaller.Bind
 
             // Generate database file.
             this.Messaging.Write(VerboseMessages.GeneratingDatabase());
-            string tempDatabaseFile = Path.Combine(this.IntermediateFolder, Path.GetFileName(this.OutputPath));
-            this.GenerateDatabase(output, tempDatabaseFile, false, false);
 
-            var transfer = this.BackendHelper.CreateFileTransfer(tempDatabaseFile, this.OutputPath, true, FileTransferType.Built); // note where this database needs to move in the future
-            fileTransfers.Add(transfer);
+            var trackMsi = this.BackendHelper.TrackFile(this.OutputPath, TrackedFileType.Final);
+            trackedFiles.Add(trackMsi);
+
+            var temporaryFiles = this.GenerateDatabase(output, trackMsi.Path, false, false);
+            trackedFiles.AddRange(temporaryFiles);
 
             // Stop processing if an error previously occurred.
             if (this.Messaging.EncounteredError)
@@ -455,7 +461,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                 var command = new MergeModulesCommand();
                 command.FileFacades = fileFacades;
                 command.Output = output;
-                command.OutputPath = tempDatabaseFile;
+                command.OutputPath = this.OutputPath;
                 command.SuppressedTableNames = suppressedTableNames;
                 command.Execute();
             }
@@ -476,7 +482,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
 
                 Messaging.Instance.Write(WixVerboses.ValidatingDatabase());
 
-                this.Validator.Validate(tempDatabaseFile);
+                this.Validator.Validate(this.OutputPath);
 
                 stopwatch.Stop();
                 Messaging.Instance.Write(WixVerboses.ValidatedDatabase(stopwatch.ElapsedMilliseconds));
@@ -498,19 +504,36 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                 command.LayoutDirectory = layoutDirectory;
                 command.LongNamesInImage = longNames;
                 command.ResolveMedia = this.ResolveMedia;
-                command.DatabasePath = tempDatabaseFile;
+                command.DatabasePath = this.OutputPath;
                 command.Execute();
 
                 fileTransfers.AddRange(command.FileTransfers);
+                trackedFiles.AddRange(command.TrackedFiles);
             }
 
-            this.FileTransfers = fileTransfers;
-            this.ContentFilePaths = fileFacades.Select(r => r.WixFile.Source.Path).ToList();
             this.Pdb = new Pdb { Output = output };
 
+            if (!String.IsNullOrEmpty(this.OutputPdbPath))
+            {
+                var trackPdb = this.BackendHelper.TrackFile(this.OutputPdbPath, TrackedFileType.Final);
+                trackedFiles.Add(trackPdb);
+
+                this.Pdb.Save(trackPdb.Path);
+            }
+
+            this.FileTransfers = fileTransfers;
+            // TODO: this is not sufficient to collect all Input files (for example, it misses Binary and Icon tables).
+            trackedFiles.AddRange(fileFacades.Select(f => this.BackendHelper.TrackFile(f.WixFile.Source.Path, TrackedFileType.Input, f.File.SourceLineNumbers))); 
+            this.TrackedFiles = trackedFiles;
+
             // TODO: Eventually this gets removed
             var intermediate = new Intermediate(this.Intermediate.Id, new[] { section }, this.Intermediate.Localizations.ToDictionary(l => l.Culture, StringComparer.OrdinalIgnoreCase), this.Intermediate.EmbedFilePaths);
-            intermediate.Save(Path.ChangeExtension(this.OutputPath, "wir"));
+            var trackIntermediate = this.BackendHelper.TrackFile(Path.Combine(this.IntermediateFolder, Path.GetFileName(Path.ChangeExtension(this.OutputPath, "wir"))), TrackedFileType.Intermediate);
+            intermediate.Save(trackIntermediate.Path);
+            trackedFiles.Add(trackIntermediate);
+
+            //transfer = this.BackendHelper.CreateFileTransfer(intermediatePath, Path.ChangeExtension(this.OutputPath, "wir"), true, FileTransferType.Built);
+            //fileTransfers.Add(transfer);
         }
 
 #if TODO_FINISH_PATCH
@@ -881,9 +904,10 @@ namespace WixToolset.Core.WindowsInstaller.Bind
         /// <param name="databaseFile">The database file to create.</param>
         /// <param name="keepAddedColumns">Whether to keep columns added in a transform.</param>
         /// <param name="useSubdirectory">Whether to use a subdirectory based on the <paramref name="databaseFile"/> file name for intermediate files.</param>
-        private void GenerateDatabase(Output output, string databaseFile, bool keepAddedColumns, bool useSubdirectory)
+        private IEnumerable<ITrackedFile> GenerateDatabase(Output output, string databaseFile, bool keepAddedColumns, bool useSubdirectory)
         {
             var command = new GenerateDatabaseCommand();
+            command.BackendHelper = this.BackendHelper;
             command.Extensions = this.FileSystemExtensions;
             command.Output = output;
             command.OutputPath = databaseFile;
@@ -891,9 +915,11 @@ namespace WixToolset.Core.WindowsInstaller.Bind
             command.UseSubDirectory = useSubdirectory;
             command.SuppressAddingValidationRows = this.SuppressAddingValidationRows;
             command.TableDefinitions = this.TableDefinitions;
-            command.TempFilesLocation = this.IntermediateFolder;
+            command.IntermediateFolder = this.IntermediateFolder;
             command.Codepage = this.Codepage;
             command.Execute();
+
+            return command.GeneratedTemporaryFiles;
         }
     }
 }
diff --git a/src/WixToolset.Core.WindowsInstaller/Bind/BindTransformCommand.cs b/src/WixToolset.Core.WindowsInstaller/Bind/BindTransformCommand.cs
index 8cb0e0de..3f5b9f05 100644
--- a/src/WixToolset.Core.WindowsInstaller/Bind/BindTransformCommand.cs
+++ b/src/WixToolset.Core.WindowsInstaller/Bind/BindTransformCommand.cs
@@ -465,7 +465,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
             command.Output = output;
             command.OutputPath = outputPath;
             command.TableDefinitions = this.TableDefinitions;
-            command.TempFilesLocation = this.TempFilesLocation;
+            command.IntermediateFolder = this.TempFilesLocation;
             command.SuppressAddingValidationRows = true;
             command.UseSubDirectory = true;
             command.Execute();
diff --git a/src/WixToolset.Core.WindowsInstaller/Bind/CabinetResolver.cs b/src/WixToolset.Core.WindowsInstaller/Bind/CabinetResolver.cs
index 759fa586..541dacf8 100644
--- a/src/WixToolset.Core.WindowsInstaller/Bind/CabinetResolver.cs
+++ b/src/WixToolset.Core.WindowsInstaller/Bind/CabinetResolver.cs
@@ -48,7 +48,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
             // to be built to and check if there is a cabinet that can be reused.
             if (!String.IsNullOrEmpty(this.CabCachePath))
             {
-                string cabinetName = Path.GetFileName(cabinetPath);
+                var cabinetName = Path.GetFileName(cabinetPath);
                 resolved.Path = Path.Combine(this.CabCachePath, cabinetName);
 
                 if (CheckFileExists(resolved.Path))
@@ -57,10 +57,10 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                     // 1. any files are added or removed
                     // 2. order of files changed or names changed
                     // 3. modified time changed
-                    bool cabinetValid = true;
+                    var cabinetValid = true;
 
                     var cabinet = new Cabinet(resolved.Path);
-                    List<CabinetFileInfo> fileList = cabinet.Enumerate();
+                    var fileList = cabinet.Enumerate();
 
                     if (filesWithPath.Count() != fileList.Count)
                     {
@@ -68,16 +68,16 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                     }
                     else
                     {
-                        int i = 0;
-                        foreach (BindFileWithPath file in filesWithPath)
+                        var i = 0;
+                        foreach (var file in filesWithPath)
                         {
                             // First check that the file identifiers match because that is quick and easy.
-                            CabinetFileInfo cabFileInfo = fileList[i];
+                            var cabFileInfo = fileList[i];
                             cabinetValid = (cabFileInfo.FileId == file.Id);
                             if (cabinetValid)
                             {
                                 // Still valid so ensure the file sizes are the same.
-                                FileInfo fileInfo = new FileInfo(file.Path);
+                                var fileInfo = new FileInfo(file.Path);
                                 cabinetValid = (cabFileInfo.Size == fileInfo.Length);
                                 if (cabinetValid)
                                 {
diff --git a/src/WixToolset.Core.WindowsInstaller/Bind/CreateCabinetsCommand.cs b/src/WixToolset.Core.WindowsInstaller/Bind/CreateCabinetsCommand.cs
index ed8f0ece..a85312c4 100644
--- a/src/WixToolset.Core.WindowsInstaller/Bind/CreateCabinetsCommand.cs
+++ b/src/WixToolset.Core.WindowsInstaller/Bind/CreateCabinetsCommand.cs
@@ -28,6 +28,8 @@ namespace WixToolset.Core.WindowsInstaller.Bind
 
         private List<IFileTransfer> fileTransfers;
 
+        private List<ITrackedFile> trackedFiles;
+
         private FileSplitCabNamesCallback newCabNamesCallBack;
 
         private Dictionary<string, string> lastCabinetAddedToMediaTable; // Key is First Cabinet Name, Value is Last Cabinet Added in the Split Sequence
@@ -36,6 +38,8 @@ namespace WixToolset.Core.WindowsInstaller.Bind
         {
             this.fileTransfers = new List<IFileTransfer>();
 
+            this.trackedFiles = new List<ITrackedFile>();
+
             this.newCabNamesCallBack = this.NewCabNamesCallBack;
 
             this.BackendHelper = backendHelper;
@@ -78,8 +82,9 @@ namespace WixToolset.Core.WindowsInstaller.Bind
 
         public IEnumerable<IFileTransfer> FileTransfers => this.fileTransfers;
 
+        public IEnumerable<ITrackedFile> TrackedFiles => this.trackedFiles;
+
         /// <param name="output">Output to generate image for.</param>
-        /// <param name="fileTransfers">Array of files to be transfered.</param>
         /// <param name="layoutDirectory">The directory in which the image should be layed out.</param>
         /// <param name="compressed">Flag if source image should be compressed.</param>
         /// <returns>The uncompressed file rows.</returns>
@@ -119,7 +124,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
 
                 string cabinetDir = this.ResolveMedia(mediaTuple, mediaLayoutFolder, this.LayoutDirectory);
 
-                CabinetWorkItem cabinetWorkItem = this.CreateCabinetWorkItem(this.Output, cabinetDir, mediaTuple, compressionLevel, files, this.fileTransfers);
+                var cabinetWorkItem = this.CreateCabinetWorkItem(this.Output, cabinetDir, mediaTuple, compressionLevel, files);
                 if (null != cabinetWorkItem)
                 {
                     cabinetBuilder.Enqueue(cabinetWorkItem);
@@ -188,9 +193,8 @@ namespace WixToolset.Core.WindowsInstaller.Bind
         /// <param name="cabinetDir">Directory to create cabinet in.</param>
         /// <param name="mediaRow">MediaRow containing information about the cabinet.</param>
         /// <param name="fileFacades">Collection of files in this cabinet.</param>
-        /// <param name="fileTransfers">Array of files to be transfered.</param>
         /// <returns>created CabinetWorkItem object</returns>
-        private CabinetWorkItem CreateCabinetWorkItem(Output output, string cabinetDir, MediaTuple mediaRow, CompressionLevel compressionLevel, IEnumerable<FileFacade> fileFacades, List<IFileTransfer> fileTransfers)
+        private CabinetWorkItem CreateCabinetWorkItem(Output output, string cabinetDir, MediaTuple mediaRow, CompressionLevel compressionLevel, IEnumerable<FileFacade> fileFacades)
         {
             CabinetWorkItem cabinetWorkItem = null;
             string tempCabinetFileX = Path.Combine(this.TempFilesLocation, mediaRow.Cabinet);
@@ -219,7 +223,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
 
             var cabinetResolver = new CabinetResolver(this.CabCachePath, this.BackendExtensions);
 
-            ResolvedCabinet resolvedCabinet = cabinetResolver.ResolveCabinet(tempCabinetFileX, fileFacades);
+            var resolvedCabinet = cabinetResolver.ResolveCabinet(tempCabinetFileX, fileFacades);
 
             // create a cabinet work item if it's not being skipped
             if (CabinetBuildOption.BuildAndCopy == resolvedCabinet.BuildOption || CabinetBuildOption.BuildAndMove == resolvedCabinet.BuildOption)
@@ -248,19 +252,24 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                 }
             }
 
+            var trackResolvedCabinet = this.BackendHelper.TrackFile(resolvedCabinet.Path, TrackedFileType.Intermediate, mediaRow.SourceLineNumbers);
+            this.trackedFiles.Add(trackResolvedCabinet);
+
             if (mediaRow.Cabinet.StartsWith("#", StringComparison.Ordinal))
             {
-                Table streamsTable = output.EnsureTable(this.TableDefinitions["_Streams"]);
+                var streamsTable = output.EnsureTable(this.TableDefinitions["_Streams"]);
 
-                Row streamRow = streamsTable.CreateRow(mediaRow.SourceLineNumbers);
+                var streamRow = streamsTable.CreateRow(mediaRow.SourceLineNumbers);
                 streamRow[0] = mediaRow.Cabinet.Substring(1);
                 streamRow[1] = resolvedCabinet.Path;
             }
             else
             {
-                var destinationPath = Path.Combine(cabinetDir, mediaRow.Cabinet);
-                var transfer = this.BackendHelper.CreateFileTransfer(resolvedCabinet.Path, destinationPath, CabinetBuildOption.BuildAndMove == resolvedCabinet.BuildOption, FileTransferType.Built, mediaRow.SourceLineNumbers);
-                fileTransfers.Add(transfer);
+                var trackDestination = this.BackendHelper.TrackFile(Path.Combine(cabinetDir, mediaRow.Cabinet), TrackedFileType.Final, mediaRow.SourceLineNumbers);
+                this.trackedFiles.Add(trackDestination);
+
+                var transfer = this.BackendHelper.CreateFileTransfer(resolvedCabinet.Path, trackDestination.Path, resolvedCabinet.BuildOption == CabinetBuildOption.BuildAndMove, mediaRow.SourceLineNumbers);
+                this.fileTransfers.Add(transfer);
             }
 
             return cabinetWorkItem;
@@ -298,10 +307,10 @@ namespace WixToolset.Core.WindowsInstaller.Bind
         /// <param name="firstCabName">The name of splitting cabinet without extention e.g. "cab1".</param>
         /// <param name="newCabName">The name of the new cabinet that would be formed by splitting e.g. "cab1b.cab"</param>
         /// <param name="fileToken">The file token of the first file present in the splitting cabinet</param>
-        internal void NewCabNamesCallBack([MarshalAs(UnmanagedType.LPWStr)]string firstCabName, [MarshalAs(UnmanagedType.LPWStr)]string newCabName, [MarshalAs(UnmanagedType.LPWStr)]string fileToken)
+        internal void NewCabNamesCallBack([MarshalAs(UnmanagedType.LPWStr)]string firstCabName, [MarshalAs(UnmanagedType.LPWStr)]string newCabinetName, [MarshalAs(UnmanagedType.LPWStr)]string fileToken)
         {
             // Locking Mutex here as this callback can come from Multiple Cabinet Builder Threads
-            Mutex mutex = new Mutex(false, "WixCabinetSplitBinderCallback");
+            var mutex = new Mutex(false, "WixCabinetSplitBinderCallback");
             try
             {
                 if (!mutex.WaitOne(0, false)) // Check if you can get the lock
@@ -311,19 +320,24 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                     mutex.WaitOne(); // Wait on other thread
                 }
 
-                string firstCabinetName = firstCabName + ".cab";
-                string newCabinetName = newCabName;
-                bool transferAdded = false; // Used for Error Handling
+                var firstCabinetName = firstCabName + ".cab";
+                var transferAdded = false; // Used for Error Handling
 
                 // Create File Transfer for new Cabinet using transfer of Base Cabinet
                 foreach (var transfer in this.FileTransfers)
                 {
                     if (firstCabinetName.Equals(Path.GetFileName(transfer.Source), StringComparison.InvariantCultureIgnoreCase))
                     {
-                        string newCabSourcePath = Path.Combine(Path.GetDirectoryName(transfer.Source), newCabinetName);
-                        string newCabTargetPath = Path.Combine(Path.GetDirectoryName(transfer.Destination), newCabinetName);
+                        var newCabSourcePath = Path.Combine(Path.GetDirectoryName(transfer.Source), newCabinetName);
+                        var newCabTargetPath = Path.Combine(Path.GetDirectoryName(transfer.Destination), newCabinetName);
+
+                        var trackSource = this.BackendHelper.TrackFile(newCabSourcePath, TrackedFileType.Intermediate, transfer.SourceLineNumbers);
+                        this.trackedFiles.Add(trackSource);
+
+                        var trackTarget = this.BackendHelper.TrackFile(newCabTargetPath, TrackedFileType.Final, transfer.SourceLineNumbers);
+                        this.trackedFiles.Add(trackTarget);
 
-                        var newTransfer = this.BackendHelper.CreateFileTransfer(newCabSourcePath, newCabTargetPath, transfer.Move, FileTransferType.Built, transfer.SourceLineNumbers);
+                        var newTransfer = this.BackendHelper.CreateFileTransfer(trackSource.Path, trackTarget.Path, transfer.Move, transfer.SourceLineNumbers);
                         this.fileTransfers.Add(newTransfer);
 
                         transferAdded = true;
@@ -338,13 +352,13 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                 }
 
                 // Add the new Cabinets to media table using LastSequence of Base Cabinet
-                Table mediaTable = this.Output.Tables["Media"];
-                Table wixFileTable = this.Output.Tables["WixFile"];
-                int diskIDForLastSplitCabAdded = 0; // The DiskID value for the first cab in this cabinet split chain
-                int lastSequenceForLastSplitCabAdded = 0; // The LastSequence value for the first cab in this cabinet split chain
-                bool lastSplitCabinetFound = false; // Used for Error Handling
+                var mediaTable = this.Output.Tables["Media"];
+                var wixFileTable = this.Output.Tables["WixFile"];
+                var diskIDForLastSplitCabAdded = 0; // The DiskID value for the first cab in this cabinet split chain
+                var lastSequenceForLastSplitCabAdded = 0; // The LastSequence value for the first cab in this cabinet split chain
+                var lastSplitCabinetFound = false; // Used for Error Handling
 
-                string lastCabinetOfThisSequence = String.Empty;
+                var lastCabinetOfThisSequence = String.Empty;
                 // Get the Value of Last Cabinet Added in this split Sequence from Dictionary
                 if (!this.lastCabinetAddedToMediaTable.TryGetValue(firstCabinetName, out lastCabinetOfThisSequence))
                 {
diff --git a/src/WixToolset.Core.WindowsInstaller/Bind/GenerateDatabaseCommand.cs b/src/WixToolset.Core.WindowsInstaller/Bind/GenerateDatabaseCommand.cs
index 3ab3b601..4e062696 100644
--- a/src/WixToolset.Core.WindowsInstaller/Bind/GenerateDatabaseCommand.cs
+++ b/src/WixToolset.Core.WindowsInstaller/Bind/GenerateDatabaseCommand.cs
@@ -14,11 +14,14 @@ namespace WixToolset.Core.WindowsInstaller.Bind
     using WixToolset.Core.Native;
     using WixToolset.Data.WindowsInstaller;
     using WixToolset.Extensibility.Services;
+    using WixToolset.Extensibility.Data;
 
     internal class GenerateDatabaseCommand 
     {
         public int Codepage { private get; set; }
 
+        public IBackendHelper BackendHelper { private get; set; }
+
         public IEnumerable<IFileSystemExtension> Extensions { private get; set; }
 
         /// <summary>
@@ -34,7 +37,9 @@ namespace WixToolset.Core.WindowsInstaller.Bind
 
         public TableDefinitionCollection TableDefinitions { private get; set; }
 
-        public string TempFilesLocation { private get; set; }
+        public string IntermediateFolder { private get; set; }
+
+        public List<ITrackedFile> GeneratedTemporaryFiles { get; } = new List<ITrackedFile>();
 
         /// <summary>
         /// Whether to use a subdirectory based on the <paramref name="databaseFile"/> file name for intermediate files.
@@ -103,7 +108,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
             }
 
             // Set the base directory.
-            string baseDirectory = this.TempFilesLocation;
+            var baseDirectory = this.IntermediateFolder;
 
             if (this.UseSubDirectory)
             {
@@ -114,7 +119,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                 Directory.CreateDirectory(baseDirectory);
             }
 
-            var idtDirectory = Path.Combine(baseDirectory, "idts");
+            var idtDirectory = Path.Combine(baseDirectory, "_idts");
             Directory.CreateDirectory(idtDirectory);
 
             try
@@ -137,6 +142,8 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                     this.Output.Codepage = this.Codepage;
                 }
 
+                Directory.CreateDirectory(Path.GetDirectoryName(this.OutputPath));
+
                 using (Database db = new Database(this.OutputPath, type))
                 {
                     // if we're not using the default codepage, import a new one into our
@@ -185,6 +192,9 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                                 var command = new CreateIdtFileCommand(this.Messaging, importTable, this.Output.Codepage, idtDirectory, this.KeepAddedColumns);
                                 command.Execute();
 
+                                var buildOutput = this.BackendHelper.TrackFile(command.IdtPath, TrackedFileType.Temporary);
+                                this.GeneratedTemporaryFiles.Add(buildOutput);
+
                                 db.Import(command.IdtPath);
                             }
                             catch (WixInvalidIdtException)
@@ -309,7 +319,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                         {
                             foreach (SubStorage subStorage in this.Output.SubStorages)
                             {
-                                string transformFile = Path.Combine(this.TempFilesLocation, String.Concat(subStorage.Name, ".mst"));
+                                string transformFile = Path.Combine(this.IntermediateFolder, String.Concat(subStorage.Name, ".mst"));
 
                                 // Bind the transform.
                                 this.BindTransform(subStorage.Data, transformFile);
@@ -346,7 +356,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
             var command = new BindTransformCommand();
             command.Messaging = this.Messaging;
             command.Extensions = this.Extensions;
-            command.TempFilesLocation = this.TempFilesLocation;
+            command.TempFilesLocation = this.IntermediateFolder;
             command.Transform = transform;
             command.OutputPath = outputPath;
             command.TableDefinitions = this.TableDefinitions;
@@ -356,8 +366,8 @@ namespace WixToolset.Core.WindowsInstaller.Bind
         private void SetDatabaseCodepage(Database db, int codepage, string idtDirectory)
         {
             // write out the _ForceCodepage IDT file
-            string idtPath = Path.Combine(idtDirectory, "_ForceCodepage.idt");
-            using (StreamWriter idtFile = new StreamWriter(idtPath, false, Encoding.ASCII))
+            var idtPath = Path.Combine(idtDirectory, "_ForceCodepage.idt");
+            using (var idtFile = new StreamWriter(idtPath, false, Encoding.ASCII))
             {
                 idtFile.WriteLine(); // dummy column name record
                 idtFile.WriteLine(); // dummy column definition record
@@ -365,6 +375,9 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                 idtFile.WriteLine("\t_ForceCodepage");
             }
 
+            var trackId = this.BackendHelper.TrackFile(idtPath, TrackedFileType.Temporary);
+            this.GeneratedTemporaryFiles.Add(trackId);
+
             // try to import the table into the MSI
             try
             {
diff --git a/src/WixToolset.Core.WindowsInstaller/Bind/ProcessUncompressedFilesCommand.cs b/src/WixToolset.Core.WindowsInstaller/Bind/ProcessUncompressedFilesCommand.cs
index b09f92bb..3ad74fd1 100644
--- a/src/WixToolset.Core.WindowsInstaller/Bind/ProcessUncompressedFilesCommand.cs
+++ b/src/WixToolset.Core.WindowsInstaller/Bind/ProcessUncompressedFilesCommand.cs
@@ -43,10 +43,14 @@ namespace WixToolset.Core.WindowsInstaller.Bind
 
         public IEnumerable<IFileTransfer> FileTransfers { get; private set; }
 
+        public IEnumerable<ITrackedFile> TrackedFiles { get; private set; }
+
         public void Execute()
         {
             var fileTransfers = new List<IFileTransfer>();
 
+            var trackedFiles = new List<ITrackedFile>();
+
             var directories = new Dictionary<string, ResolvedDirectory>();
 
             var mediaRows = this.Section.Tuples.OfType<MediaTuple>().ToDictionary(t => t.DiskId);
@@ -108,14 +112,26 @@ namespace WixToolset.Core.WindowsInstaller.Bind
 
                             // finally put together the base media layout path and the relative file layout path
                             var fileLayoutPath = Path.Combine(mediaLayoutDirectory, relativeFileLayoutPath);
-                            var transfer = this.BackendHelper.CreateFileTransfer(facade.WixFile.Source.Path, fileLayoutPath, false, FileTransferType.Content, facade.File.SourceLineNumbers);
+
+                            var transfer = this.BackendHelper.CreateFileTransfer(facade.WixFile.Source.Path, fileLayoutPath, false, facade.File.SourceLineNumbers);
                             fileTransfers.Add(transfer);
+
+                            // Track the location where the cabinet will be placed. If the transfer is
+                            // redundant then then the file should not be cleaned. This is important
+                            // because if the source and destination of the transfer is the same, we
+                            // don't want to clean the file because we'd be deleting the original
+                            // (and that would be bad).
+                            var tracked = this.BackendHelper.TrackFile(transfer.Destination, TrackedFileType.Final, facade.File.SourceLineNumbers);
+                            tracked.Clean = !transfer.Redundant;
+
+                            trackedFiles.Add(tracked);
                         }
                     }
                 }
             }
 
             this.FileTransfers = fileTransfers;
+            this.TrackedFiles = trackedFiles;
         }
     }
 }
diff --git a/src/WixToolset.Core.WindowsInstaller/MsiBackend.cs b/src/WixToolset.Core.WindowsInstaller/MsiBackend.cs
index f72a7c66..c0c518f8 100644
--- a/src/WixToolset.Core.WindowsInstaller/MsiBackend.cs
+++ b/src/WixToolset.Core.WindowsInstaller/MsiBackend.cs
@@ -29,18 +29,12 @@ namespace WixToolset.Core.WindowsInstaller
             var command = new BindDatabaseCommand(context, backendExtensions, validator);
             command.Execute();
 
-            var result = new BindResult { FileTransfers = command.FileTransfers, ContentFilePaths = command.ContentFilePaths };
+            var result = new BindResult { FileTransfers = command.FileTransfers, TrackedFiles = command.TrackedFiles };
 
             foreach (var extension in backendExtensions)
             {
                 extension.PostBackendBind(result, command.Pdb);
             }
-
-            if (!String.IsNullOrEmpty(context.OutputPdbPath))
-            {
-                command.Pdb?.Save(context.OutputPdbPath);
-            }
-
             return result;
         }
 
diff --git a/src/WixToolset.Core.WindowsInstaller/MsmBackend.cs b/src/WixToolset.Core.WindowsInstaller/MsmBackend.cs
index 91377b48..6c97f08d 100644
--- a/src/WixToolset.Core.WindowsInstaller/MsmBackend.cs
+++ b/src/WixToolset.Core.WindowsInstaller/MsmBackend.cs
@@ -28,7 +28,7 @@ namespace WixToolset.Core.WindowsInstaller
             var command = new BindDatabaseCommand(context, backendExtensions, validator);
             command.Execute();
 
-            var result = new BindResult { FileTransfers = command.FileTransfers, ContentFilePaths = command.ContentFilePaths };
+            var result = new BindResult { FileTransfers = command.FileTransfers, TrackedFiles = command.TrackedFiles };
 
             foreach (var extension in backendExtensions)
             {
diff --git a/src/WixToolset.Core.WindowsInstaller/Unbind/UnbindTranformCommand.cs b/src/WixToolset.Core.WindowsInstaller/Unbind/UnbindTranformCommand.cs
index 80401822..3c32719e 100644
--- a/src/WixToolset.Core.WindowsInstaller/Unbind/UnbindTranformCommand.cs
+++ b/src/WixToolset.Core.WindowsInstaller/Unbind/UnbindTranformCommand.cs
@@ -251,7 +251,7 @@ namespace WixToolset.Core.WindowsInstaller.Unbind
             command.UseSubDirectory = false;
             command.SuppressAddingValidationRows = true;
             command.TableDefinitions = this.TableDefinitions;
-            command.TempFilesLocation = this.IntermediateFolder;
+            command.IntermediateFolder = this.IntermediateFolder;
             command.Codepage = -1;
             command.Execute();
         }
diff --git a/src/WixToolset.Core/CommandLine/BuildCommand.cs b/src/WixToolset.Core/CommandLine/BuildCommand.cs
index 5c089b5f..b460e48f 100644
--- a/src/WixToolset.Core/CommandLine/BuildCommand.cs
+++ b/src/WixToolset.Core/CommandLine/BuildCommand.cs
@@ -276,8 +276,9 @@ namespace WixToolset.Core.CommandLine
 
             {
                 var layout = new Layout(this.ServiceProvider);
+                layout.TrackedFiles = bindResult.TrackedFiles;
                 layout.FileTransfers = bindResult.FileTransfers;
-                layout.ContentFilePaths = bindResult.ContentFilePaths;
+                layout.IntermediateFolder = this.IntermediateFolder;
                 layout.ContentsFile = this.ContentsFile;
                 layout.OutputsFile = this.OutputsFile;
                 layout.BuiltOutputsFile = this.BuiltOutputsFile;
diff --git a/src/WixToolset.Core/ExtensibilityServices/BackendHelper.cs b/src/WixToolset.Core/ExtensibilityServices/BackendHelper.cs
index 0cda4437..6cc91487 100644
--- a/src/WixToolset.Core/ExtensibilityServices/BackendHelper.cs
+++ b/src/WixToolset.Core/ExtensibilityServices/BackendHelper.cs
@@ -19,18 +19,17 @@ namespace WixToolset.Core.ExtensibilityServices
 
         private IMessaging Messaging { get; }
 
-        public IFileTransfer CreateFileTransfer(string source, string destination, bool move, FileTransferType type, SourceLineNumber sourceLineNumbers)
+        public IFileTransfer CreateFileTransfer(string source, string destination, bool move, SourceLineNumber sourceLineNumbers = null)
         {
-            var sourceFullPath = GetValidatedFullPath(sourceLineNumbers, source);
+            var sourceFullPath = this.GetValidatedFullPath(sourceLineNumbers, source);
 
-            var destinationFullPath = GetValidatedFullPath(sourceLineNumbers, destination);
+            var destinationFullPath = this.GetValidatedFullPath(sourceLineNumbers, destination);
 
             return (String.IsNullOrEmpty(sourceFullPath) || String.IsNullOrEmpty(destinationFullPath)) ? null : new FileTransfer
             {
                 Source = sourceFullPath,
                 Destination = destinationFullPath,
                 Move = move,
-                Type = type,
                 SourceLineNumbers = sourceLineNumbers,
                 Redundant = String.Equals(sourceFullPath, destinationFullPath, StringComparison.OrdinalIgnoreCase)
             };
@@ -41,6 +40,11 @@ namespace WixToolset.Core.ExtensibilityServices
             return Uuid.NewUuid(namespaceGuid, value).ToString("B").ToUpperInvariant();
         }
 
+        public ITrackedFile TrackFile(string path, TrackedFileType type, SourceLineNumber sourceLineNumbers = null)
+        {
+            return new TrackedFile(path, type, sourceLineNumbers);
+        }
+
         private string GetValidatedFullPath(SourceLineNumber sourceLineNumbers, string path)
         {
             try
diff --git a/src/WixToolset.Core/FileTransfer.cs b/src/WixToolset.Core/FileTransfer.cs
index 9da406eb..7f9ed0f3 100644
--- a/src/WixToolset.Core/FileTransfer.cs
+++ b/src/WixToolset.Core/FileTransfer.cs
@@ -15,8 +15,6 @@ namespace WixToolset.Core
 
         public SourceLineNumber SourceLineNumbers { get; set; }
 
-        public FileTransferType Type { get; set; }
-
         public bool Redundant { get; set; }
     }
 }
diff --git a/src/WixToolset.Core/Layout.cs b/src/WixToolset.Core/Layout.cs
index 128efc61..b1b03aa7 100644
--- a/src/WixToolset.Core/Layout.cs
+++ b/src/WixToolset.Core/Layout.cs
@@ -28,9 +28,11 @@ namespace WixToolset.Core
 
         private IMessaging Messaging { get; }
 
+        public IEnumerable<ITrackedFile> TrackedFiles { get; set; }
+
         public IEnumerable<IFileTransfer> FileTransfers { get; set; }
 
-        public IEnumerable<string> ContentFilePaths { get; set; }
+        public string IntermediateFolder { get; set; }
 
         public string ContentsFile { get; set; }
 
@@ -46,8 +48,8 @@ namespace WixToolset.Core
 
             var context = this.ServiceProvider.GetService<ILayoutContext>();
             context.Extensions = extensionManager.Create<ILayoutExtension>();
+            context.TrackedFiles = this.TrackedFiles;
             context.FileTransfers = this.FileTransfers;
-            context.ContentFilePaths = this.ContentFilePaths;
             context.ContentsFile = this.ContentsFile;
             context.OutputsFile = this.OutputsFile;
             context.BuiltOutputsFile = this.BuiltOutputsFile;
@@ -71,24 +73,29 @@ namespace WixToolset.Core
                     var command = new TransferFilesCommand(this.Messaging, context.Extensions, context.FileTransfers, context.SuppressAclReset);
                     command.Execute();
                 }
+
+                if (context.TrackedFiles != null)
+                {
+                    this.CleanTempFiles(context.TrackedFiles);
+                }
             }
             finally
             {
-                if (!String.IsNullOrEmpty(context.ContentsFile) && context.ContentFilePaths != null)
+                if (context.TrackedFiles != null)
                 {
-                    this.CreateContentsFile(context.ContentsFile, context.ContentFilePaths);
-                }
+                    if (!String.IsNullOrEmpty(context.ContentsFile))
+                    {
+                        this.CreateContentsFile(context.ContentsFile, context.TrackedFiles);
+                    }
 
-                if (context.FileTransfers != null)
-                {
                     if (!String.IsNullOrEmpty(context.OutputsFile))
                     {
-                        this.CreateOutputsFile(context.OutputsFile, context.FileTransfers);
+                        this.CreateOutputsFile(context.OutputsFile, context.TrackedFiles);
                     }
 
                     if (!String.IsNullOrEmpty(context.BuiltOutputsFile))
                     {
-                        this.CreateBuiltOutputsFile(context.BuiltOutputsFile, context.FileTransfers);
+                        this.CreateBuiltOutputsFile(context.BuiltOutputsFile, context.TrackedFiles);
                     }
                 }
             }
@@ -105,16 +112,23 @@ namespace WixToolset.Core
         /// </summary>
         /// <param name="path">Path to write file.</param>
         /// <param name="contentFilePaths">Collection of paths to content files that will be written to file.</param>
-        private void CreateContentsFile(string path, IEnumerable<string> contentFilePaths)
+        private void CreateContentsFile(string path, IEnumerable<ITrackedFile> trackedFiles)
         {
+            var uniqueInputFilePaths = new SortedSet<string>(trackedFiles.Where(t => t.Type == TrackedFileType.Input).Select(t => t.Path), StringComparer.OrdinalIgnoreCase);
+
+            if (!uniqueInputFilePaths.Any())
+            {
+                return;
+            }
+
             var directory = Path.GetDirectoryName(path);
             Directory.CreateDirectory(directory);
 
             using (var contents = new StreamWriter(path, false))
             {
-                foreach (string contentPath in contentFilePaths)
+                foreach (string inputPath in uniqueInputFilePaths)
                 {
-                    contents.WriteLine(contentPath);
+                    contents.WriteLine(inputPath);
                 }
             }
         }
@@ -124,22 +138,28 @@ namespace WixToolset.Core
         /// </summary>
         /// <param name="path">Path to write file.</param>
         /// <param name="fileTransfers">Collection of files that were transferred to the output directory.</param>
-        private void CreateOutputsFile(string path, IEnumerable<IFileTransfer> fileTransfers)
+        private void CreateOutputsFile(string path, IEnumerable<ITrackedFile> trackedFiles)
         {
+            var uniqueOutputPaths = new SortedSet<string>(trackedFiles.Where(t => t.Clean).Select(t => t.Path), StringComparer.OrdinalIgnoreCase);
+
+            if (!uniqueOutputPaths.Any())
+            {
+                return;
+            }
+
             var directory = Path.GetDirectoryName(path);
             Directory.CreateDirectory(directory);
 
             using (var outputs = new StreamWriter(path, false))
             {
-                foreach (var fileTransfer in fileTransfers)
+                //// Don't list files where the source is the same as the destination since
+                //// that might be the only place the file exists. The outputs file is often
+                //// used to delete stuff and losing the original source would be bad.
+                //var uniqueOutputPaths = new SortedSet<string>(fileTransfers.Where(ft => !ft.Redundant).Select(ft => ft.Destination), StringComparer.OrdinalIgnoreCase);
+
+                foreach (var outputPath in uniqueOutputPaths)
                 {
-                    // Don't list files where the source is the same as the destination since
-                    // that might be the only place the file exists. The outputs file is often
-                    // used to delete stuff and losing the original source would be bad.
-                    if (!fileTransfer.Redundant)
-                    {
-                        outputs.WriteLine(fileTransfer.Destination);
-                    }
+                    outputs.WriteLine(outputPath);
                 }
             }
         }
@@ -149,21 +169,83 @@ namespace WixToolset.Core
         /// </summary>
         /// <param name="path">Path to write file.</param>
         /// <param name="fileTransfers">Collection of files that were transferred to the output directory.</param>
-        private void CreateBuiltOutputsFile(string path, IEnumerable<IFileTransfer> fileTransfers)
+        private void CreateBuiltOutputsFile(string path, IEnumerable<ITrackedFile> trackedFiles)
         {
+            var uniqueBuiltPaths = new SortedSet<string>(trackedFiles.Where(t => t.Type == TrackedFileType.Final).Select(t => t.Path), StringComparer.OrdinalIgnoreCase);
+
+            if (!uniqueBuiltPaths.Any())
+            {
+                return;
+            }
+
             var directory = Path.GetDirectoryName(path);
             Directory.CreateDirectory(directory);
 
             using (var outputs = new StreamWriter(path, false))
             {
-                foreach (var fileTransfer in fileTransfers)
+                foreach (var builtPath in uniqueBuiltPaths)
                 {
-                    // Only write the built file transfers. Also, skip redundant
-                    // files for the same reason spelled out in this.CreateOutputsFile().
-                    if (fileTransfer.Type == FileTransferType.Built && !fileTransfer.Redundant)
-                    {
-                        outputs.WriteLine(fileTransfer.Destination);
-                    }
+                    outputs.WriteLine(builtPath);
+                }
+            }
+        }
+
+        private void CleanTempFiles(IEnumerable<ITrackedFile> trackedFiles)
+        {
+            var uniqueTempPaths = new SortedSet<string>(trackedFiles.Where(t => t.Type == TrackedFileType.Temporary).Select(t => t.Path), StringComparer.OrdinalIgnoreCase);
+
+            if (!uniqueTempPaths.Any())
+            {
+                return;
+            }
+
+            var uniqueFolders = new SortedSet<string>(StringComparer.OrdinalIgnoreCase)
+            {
+                this.IntermediateFolder
+            };
+
+            // Clean up temp files.
+            foreach (var tempPath in uniqueTempPaths)
+            {
+                try
+                {
+                    this.SplitUniqueFolders(tempPath, uniqueFolders);
+
+                    File.Delete(tempPath);
+                }
+                catch // delete is best effort.
+                {
+                }
+            }
+
+            // Clean up empty temp folders.
+            foreach (var folder in uniqueFolders.Reverse())
+            {
+                try
+                {
+                    Directory.Delete(folder);
+                }
+                catch // delete is best effort.
+                {
+                }
+            }
+        }
+
+        private void SplitUniqueFolders(string tempPath, SortedSet<string> uniqueFolders)
+        {
+            if (tempPath.StartsWith(this.IntermediateFolder, StringComparison.OrdinalIgnoreCase))
+            {
+                var folder = Path.GetDirectoryName(tempPath).Substring(this.IntermediateFolder.Length);
+
+                var parts = folder.Split(new[] { '\\', '/' }, StringSplitOptions.RemoveEmptyEntries);
+
+                folder = this.IntermediateFolder;
+
+                foreach (var part in parts)
+                {
+                    folder = Path.Combine(folder, part);
+
+                    uniqueFolders.Add(folder);
                 }
             }
         }
diff --git a/src/WixToolset.Core/LayoutContext.cs b/src/WixToolset.Core/LayoutContext.cs
index 99ca611a..20d29b5f 100644
--- a/src/WixToolset.Core/LayoutContext.cs
+++ b/src/WixToolset.Core/LayoutContext.cs
@@ -22,7 +22,7 @@ namespace WixToolset.Core
 
         public IEnumerable<IFileTransfer> FileTransfers { get; set; }
 
-        public IEnumerable<string> ContentFilePaths { get; set; }
+        public IEnumerable<ITrackedFile> TrackedFiles { get; set; }
 
         public string OutputPdbPath { get; set; }
 
diff --git a/src/WixToolset.Core/TrackedFile.cs b/src/WixToolset.Core/TrackedFile.cs
new file mode 100644
index 00000000..312b09f4
--- /dev/null
+++ b/src/WixToolset.Core/TrackedFile.cs
@@ -0,0 +1,26 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.Core
+{
+    using WixToolset.Data;
+    using WixToolset.Extensibility.Data;
+
+    internal class TrackedFile : ITrackedFile
+    {
+        public TrackedFile(string path, TrackedFileType type, SourceLineNumber sourceLineNumbers)
+        {
+            this.Path = path;
+            this.Type = type;
+            this.SourceLineNumbers = sourceLineNumbers;
+            this.Clean = (type == TrackedFileType.Intermediate || type == TrackedFileType.Final);
+        }
+
+        public bool Clean { get; set; }
+
+        public string Path { get; set; }
+
+        public SourceLineNumber SourceLineNumbers { get; set; }
+
+        public TrackedFileType Type { get; set; }
+    }
+}
diff --git a/src/test/WixToolsetTest.CoreIntegration/ExtensionFixture.cs b/src/test/WixToolsetTest.CoreIntegration/ExtensionFixture.cs
index cc631c22..e96c2ddd 100644
--- a/src/test/WixToolsetTest.CoreIntegration/ExtensionFixture.cs
+++ b/src/test/WixToolsetTest.CoreIntegration/ExtensionFixture.cs
@@ -56,7 +56,7 @@ namespace WixToolsetTest.CoreIntegration
                 Assert.True(File.Exists(Path.Combine(intermediateFolder, @"bin\extest.wixpdb")));
                 Assert.True(File.Exists(Path.Combine(intermediateFolder, @"bin\MsiPackage\example.txt")));
 
-                var intermediate = Intermediate.Load(Path.Combine(intermediateFolder, @"bin\extest.wir"));
+                var intermediate = Intermediate.Load(Path.Combine(intermediateFolder, @"extest.wir"));
                 var section = intermediate.Sections.Single();
 
                 var wixFile = section.Tuples.OfType<WixFileTuple>().Single();
@@ -95,7 +95,7 @@ namespace WixToolsetTest.CoreIntegration
 
                 Assert.Equal(0, result);
 
-                var intermediate = Intermediate.Load(Path.Combine(intermediateFolder, @"bin\extest.wir"));
+                var intermediate = Intermediate.Load(Path.Combine(intermediateFolder, @"extest.wir"));
                 var section = intermediate.Sections.Single();
 
                 var property = section.Tuples.OfType<PropertyTuple>().Where(p => p.Id.Id == "ExampleProperty").Single();
diff --git a/src/test/WixToolsetTest.CoreIntegration/MsiFixture.cs b/src/test/WixToolsetTest.CoreIntegration/MsiFixture.cs
index 9d46ba98..126f334d 100644
--- a/src/test/WixToolsetTest.CoreIntegration/MsiFixture.cs
+++ b/src/test/WixToolsetTest.CoreIntegration/MsiFixture.cs
@@ -39,7 +39,7 @@ namespace WixToolsetTest.CoreIntegration
                 Assert.True(File.Exists(Path.Combine(baseFolder, @"bin\test.wixpdb")));
                 Assert.True(File.Exists(Path.Combine(baseFolder, @"bin\MsiPackage\test.txt")));
 
-                var intermediate = Intermediate.Load(Path.Combine(baseFolder, @"bin\test.wir"));
+                var intermediate = Intermediate.Load(Path.Combine(intermediateFolder, @"test.wir"));
                 var section = intermediate.Sections.Single();
 
                 var wixFile = section.Tuples.OfType<WixFileTuple>().Single();
@@ -74,7 +74,7 @@ namespace WixToolsetTest.CoreIntegration
                 Assert.True(File.Exists(Path.Combine(intermediateFolder, @"bin\example.cab")));
                 Assert.True(File.Exists(Path.Combine(intermediateFolder, @"bin\test.wixpdb")));
 
-                var intermediate = Intermediate.Load(Path.Combine(intermediateFolder, @"bin\test.wir"));
+                var intermediate = Intermediate.Load(Path.Combine(intermediateFolder, @"test.wir"));
                 var section = intermediate.Sections.Single();
 
                 var wixFile = section.Tuples.OfType<WixFileTuple>().Single();
@@ -264,7 +264,7 @@ namespace WixToolsetTest.CoreIntegration
                 Assert.True(File.Exists(Path.Combine(intermediateFolder, @"bin\test.msm")));
                 Assert.True(File.Exists(Path.Combine(intermediateFolder, @"bin\test.wixpdb")));
 
-                var intermediate = Intermediate.Load(Path.Combine(intermediateFolder, @"bin\test.wir"));
+                var intermediate = Intermediate.Load(Path.Combine(intermediateFolder, @"test.wir"));
                 var section = intermediate.Sections.Single();
 
                 var wixFile = section.Tuples.OfType<WixFileTuple>().Single();
@@ -299,7 +299,7 @@ namespace WixToolsetTest.CoreIntegration
                 Assert.True(File.Exists(Path.Combine(intermediateFolder, @"bin\test.wixpdb")));
                 Assert.True(File.Exists(Path.Combine(intermediateFolder, @"bin\MsiPackage\test.txt")));
 
-                var intermediate = Intermediate.Load(Path.Combine(intermediateFolder, @"bin\test.wir"));
+                var intermediate = Intermediate.Load(Path.Combine(intermediateFolder, @"test.wir"));
                 var section = intermediate.Sections.Single();
 
                 var wixFile = section.Tuples.OfType<WixFileTuple>().Single();
@@ -399,7 +399,7 @@ namespace WixToolsetTest.CoreIntegration
                 Assert.True(File.Exists(Path.Combine(baseFolder, @"bin\test.wixpdb")));
                 Assert.True(File.Exists(Path.Combine(baseFolder, @"bin\MsiPackage\test.txt")));
 
-                var intermediate = Intermediate.Load(Path.Combine(baseFolder, @"bin\test.wir"));
+                var intermediate = Intermediate.Load(Path.Combine(intermediateFolder, @"test.wir"));
                 var section = intermediate.Sections.Single();
 
                 var wixFile = section.Tuples.OfType<WixFileTuple>().Single();
@@ -435,7 +435,7 @@ namespace WixToolsetTest.CoreIntegration
                 Assert.True(File.Exists(Path.Combine(baseFolder, @"bin\test.wixpdb")));
                 Assert.True(File.Exists(Path.Combine(baseFolder, @"bin\AssemblyMsiPackage\candle.exe")));
 
-                var intermediate = Intermediate.Load(Path.Combine(baseFolder, @"bin\test.wir"));
+                var intermediate = Intermediate.Load(Path.Combine(baseFolder, @"test.wir"));
                 var section = intermediate.Sections.Single();
 
                 var wixFile = section.Tuples.OfType<WixFileTuple>().Single();
diff --git a/src/test/WixToolsetTest.CoreIntegration/WixiplFixture.cs b/src/test/WixToolsetTest.CoreIntegration/WixiplFixture.cs
index 498b1492..a51d831f 100644
--- a/src/test/WixToolsetTest.CoreIntegration/WixiplFixture.cs
+++ b/src/test/WixToolsetTest.CoreIntegration/WixiplFixture.cs
@@ -43,7 +43,7 @@ namespace WixToolsetTest.CoreIntegration
                 }, out var messagesBind);
                 Assert.Equal(0, result);
 
-                var intermediate = Intermediate.Load(Path.Combine(baseFolder, @"bin\test.wir"));
+                var intermediate = Intermediate.Load(Path.Combine(baseFolder, @"obj\test.wir"));
                 var section = intermediate.Sections.Single();
 
                 var wixFile = section.Tuples.OfType<WixFileTuple>().Single();