Isolate MSBuildTaskHost from the rest of MSBuild Codebase

src/Build.UnitTests/Microsoft.Build.Engine.UnitTests.csproj

@@ -77,9 +77,6 @@
     <Compile Include="..\Shared\UnitTests\CopyOnWriteDictionary_Tests.cs">
       <Link>Collections\CopyOnWriteDictionary_Tests.cs</Link>
     </Compile>
-    <Compile Include="..\Shared\UnitTests\ImmutableDictionary_Tests.cs" Condition="'$(TargetFrameworkIdentifier)' == '.NETFramework' and '$(MSBuildRuntimeType)' == 'Full'">
-      <Link>Collections\ImmutableDictionary_Tests.cs</Link>
-    </Compile>
     <Compile Include="..\GlobalUsings.cs" Link="GlobalUsings.cs" />
 
     <None Include="..\Shared\UnitTests\App.config">

src/Directory.BeforeCommon.targets

@@ -14,7 +14,7 @@
     <DefineConstants>$(DefineConstants);FEATURE_DEBUG_LAUNCH</DefineConstants>
   </PropertyGroup>
 
-  <PropertyGroup Condition="$(TargetFramework.StartsWith('net4')) Or $(TargetFramework.StartsWith('net3'))">
+  <PropertyGroup Condition="$(TargetFramework.StartsWith('net4'))">
     <DefineConstants>$(DefineConstants);FEATURE_APARTMENT_STATE</DefineConstants>
     <DefineConstants>$(DefineConstants);FEATURE_APM</DefineConstants>
     <DefineConstants>$(DefineConstants);FEATURE_APPDOMAIN</DefineConstants>
@@ -71,6 +71,10 @@
     <DefineConstants>$(DefineConstants);FEATURE_MSCOREE</DefineConstants>
   </PropertyGroup>
 
+  <PropertyGroup Condition="$(TargetFramework.StartsWith('net3'))">
+    <DefineConstants>$(DefineConstants);FEATURE_APARTMENT_STATE</DefineConstants>
+  </PropertyGroup>
+
   <PropertyGroup>
     <!-- Useful for tests that need OS information as a constant -->
     <DefineConstants Condition="$([MSBuild]::IsOSPlatform('windows'))">$(DefineConstants);TEST_ISWINDOWS</DefineConstants>

src/MSBuildTaskHost/AssemblyLoadInfo.cs

@@ -0,0 +1,232 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.Diagnostics;
+using System.IO;
+using Microsoft.Build.BackEnd;
+
+#nullable disable
+
+namespace Microsoft.Build.Shared
+{
+    /// <summary>
+    /// This class packages information about how to load a given assembly -- an assembly can be loaded by either its assembly
+    /// name (strong or weak), or its filename/path.
+    /// </summary>
+    /// <remarks>
+    /// Uses factory to instantiate correct private class to save space: only one field is ever used of the two.
+    /// </remarks>
+    internal abstract class AssemblyLoadInfo : ITranslatable, IEquatable<AssemblyLoadInfo>
+    {
+        /// <summary>
+        /// This constructor initializes the assembly information.
+        /// </summary>
+        internal static AssemblyLoadInfo Create(string assemblyName, string assemblyFile)
+        {
+            ErrorUtilities.VerifyThrow((!string.IsNullOrEmpty(assemblyName)) || (!string.IsNullOrEmpty(assemblyFile)),
+                "We must have either the assembly name or the assembly file/path.");
+            ErrorUtilities.VerifyThrow((assemblyName == null) || (assemblyFile == null),
+                "We must not have both the assembly name and the assembly file/path.");
+
+            if (assemblyName != null)
+            {
+                return new AssemblyLoadInfoWithName(assemblyName);
+            }
+            else
+            {
+                return new AssemblyLoadInfoWithFile(assemblyFile);
+            }
+        }
+
+        /// <summary>
+        /// Gets the assembly's identity denoted by its strong/weak name.
+        /// </summary>
+        public abstract string AssemblyName
+        {
+            get;
+        }
+
+        /// <summary>
+        /// Gets the path to the assembly file.
+        /// </summary>
+        public abstract string AssemblyFile
+        {
+            get;
+        }
+
+        /// <summary>
+        /// Get the assembly location
+        /// </summary>
+        internal abstract string AssemblyLocation
+        {
+            get;
+        }
+
+        /// <summary>
+        /// Gets whether this assembly is an inline task assembly that should be loaded from bytes to avoid file locking.
+        /// </summary>
+        internal abstract bool IsInlineTask
+        {
+            get;
+        }
+
+        /// <summary>
+        /// Computes a hashcode for this assembly info, so this object can be used as a key into
+        /// a hash table.
+        /// </summary>
+        public override int GetHashCode()
+        {
+            return AssemblyLocation.GetHashCode();
+        }
+
+        public bool Equals(AssemblyLoadInfo other)
+        {
+            return Equals((object)other);
+        }
+
+        /// <summary>
+        /// Determines if two AssemblyLoadInfos are effectively the same.
+        /// </summary>
+        public override bool Equals(Object obj)
+        {
+            if (obj == null)
+            {
+                return false;
+            }
+
+            AssemblyLoadInfo otherAssemblyInfo = obj as AssemblyLoadInfo;
+
+            if (otherAssemblyInfo == null)
+            {
+                return false;
+            }
+
+            return (this.AssemblyName == otherAssemblyInfo.AssemblyName) && (this.AssemblyFile == otherAssemblyInfo.AssemblyFile);
+        }
+
+        public void Translate(ITranslator translator)
+        {
+            ErrorUtilities.VerifyThrow(translator.Mode == TranslationDirection.WriteToStream, "write only");
+            string assemblyName = AssemblyName;
+            string assemblyFile = AssemblyFile;
+            translator.Translate(ref assemblyName);
+            translator.Translate(ref assemblyFile);
+        }
+
+        public static AssemblyLoadInfo FactoryForTranslation(ITranslator translator)
+        {
+            string assemblyName = null;
+            string assemblyFile = null;
+            translator.Translate(ref assemblyName);
+            translator.Translate(ref assemblyFile);
+
+            return Create(assemblyName, assemblyFile);
+        }
+
+        /// <summary>
+        /// Assembly represented by name
+        /// </summary>
+        [DebuggerDisplay("{AssemblyName}")]
+        private sealed class AssemblyLoadInfoWithName : AssemblyLoadInfo
+        {
+            /// <summary>
+            /// Assembly name
+            /// </summary>
+            private string _assemblyName;
+
+            /// <summary>
+            /// Constructor
+            /// </summary>
+            internal AssemblyLoadInfoWithName(string assemblyName)
+            {
+                _assemblyName = assemblyName;
+            }
+
+            /// <summary>
+            /// Gets the assembly's identity denoted by its strong/weak name.
+            /// </summary>
+            public override string AssemblyName
+            {
+                get { return _assemblyName; }
+            }
+
+            /// <summary>
+            /// Gets the path to the assembly file.
+            /// </summary>
+            public override string AssemblyFile
+            {
+                get { return null; }
+            }
+
+            /// <summary>
+            /// Get the assembly location
+            /// </summary>
+            internal override string AssemblyLocation
+            {
+                get { return _assemblyName; }
+            }
+
+            /// <summary>
+            /// Gets whether this assembly is an inline task assembly.
+            /// Assembly names are never inline tasks.
+            /// </summary>
+            internal override bool IsInlineTask
+            {
+                get { return false; }
+            }
+        }
+
+        /// <summary>
+        /// Assembly info that uses a file path
+        /// </summary>
+        [DebuggerDisplay("{AssemblyFile}")]
+        private sealed class AssemblyLoadInfoWithFile : AssemblyLoadInfo
+        {
+            /// <summary>
+            /// Path to assembly
+            /// </summary>
+            private string _assemblyFile;
+
+            /// <summary>
+            /// Constructor
+            /// </summary>
+            internal AssemblyLoadInfoWithFile(string assemblyFile)
+            {
+                ErrorUtilities.VerifyThrow(Path.IsPathRooted(assemblyFile), "Assembly file path should be rooted");
+
+                _assemblyFile = assemblyFile;
+            }
+
+            /// <summary>
+            /// Gets the assembly's identity denoted by its strong/weak name.
+            /// </summary>
+            public override string AssemblyName
+            {
+                get { return null; }
+            }
+
+            /// <summary>
+            /// Gets the path to the assembly file.
+            /// </summary>
+            public override string AssemblyFile
+            {
+                get { return _assemblyFile; }
+            }
+
+            /// <summary>
+            /// Get the assembly location
+            /// </summary>
+            internal override string AssemblyLocation
+            {
+                get { return _assemblyFile; }
+            }
+
+            /// <summary>
+            /// Gets whether this assembly is an inline task assembly.
+            /// Detects inline tasks by checking if the file path ends with the inline task suffix.
+            /// </summary>
+            internal override bool IsInlineTask => false;
+        }
+    }
+}

src/MSBuildTaskHost/BinaryReaderExtensions.cs

@@ -0,0 +1,74 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+
+namespace Microsoft.Build.Shared
+{
+    internal static class BinaryReaderExtensions
+    {
+        public static string? ReadOptionalString(this BinaryReader reader)
+        {
+            return reader.ReadByte() == 0 ? null : reader.ReadString();
+        }
+
+        public static int? ReadOptionalInt32(this BinaryReader reader)
+        {
+            return reader.ReadByte() == 0 ? null : reader.ReadInt32();
+        }
+
+        public static int Read7BitEncodedInt(this BinaryReader reader)
+        {
+            // Read out an Int32 7 bits at a time.  The high bit
+            // of the byte when on means to continue reading more bytes.
+            int count = 0;
+            int shift = 0;
+            byte b;
+            do
+            {
+                // Check for a corrupted stream.  Read a max of 5 bytes.
+                // In a future version, add a DataFormatException.
+                if (shift == 5 * 7)  // 5 bytes max per Int32, shift += 7
+                {
+                    throw new FormatException();
+                }
+
+                // ReadByte handles end of stream cases for us.
+                b = reader.ReadByte();
+                count |= (b & 0x7F) << shift;
+                shift += 7;
+            } while ((b & 0x80) != 0);
+            return count;
+        }
+
+        public static DateTime ReadTimestamp(this BinaryReader reader)
+        {
+            long timestampTicks = reader.ReadInt64();
+            DateTimeKind kind = (DateTimeKind)reader.ReadInt32();
+            var timestamp = new DateTime(timestampTicks, kind);
+            return timestamp;
+        }
+
+        public static unsafe Guid ReadGuid(this BinaryReader reader)
+        {
+            return new Guid(reader.ReadBytes(sizeof(Guid)));
+        }
+
+        public static Dictionary<string, TimeSpan> ReadDurationDictionary(this BinaryReader reader)
+        {
+            int count = reader.Read7BitEncodedInt();
+            var durations = new Dictionary<string, TimeSpan>(count);
+            for (int i = 0; i < count; i++)
+            {
+                string key = reader.ReadString();
+                TimeSpan value = TimeSpan.FromTicks(reader.ReadInt64());
+
+                durations.Add(key, value);
+            }
+
+            return durations;
+        }
+    }
+}