Add implicit architecture/runtime detection for custom tasks

src/Build.UnitTests/BackEnd/AssemblyTaskFactory_E2E_Tests.cs

@@ -0,0 +1,67 @@
+// 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.IO;
+using Microsoft.Build.Shared;
+using Microsoft.Build.UnitTests;
+using Microsoft.Build.UnitTests.Shared;
+using Shouldly;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace Microsoft.Build.Engine.UnitTests
+{
+    public class AssemblyTaskFactory_E2E_Tests
+    {
+        private static string AssemblyLocation { get; } = Path.Combine(Path.GetDirectoryName(typeof(NetTaskHost_E2E_Tests).Assembly.Location) ?? AppContext.BaseDirectory);
+
+        private static string TestAssetsRootPath { get; } = Path.Combine(AssemblyLocation, "TestAssets");
+
+        private readonly ITestOutputHelper _output;
+
+        public AssemblyTaskFactory_E2E_Tests(ITestOutputHelper output)
+        {
+            _output = output;
+        }
+
+        [WindowsFullFrameworkOnlyFact]
+        public void FrameworkTaskArchitectureMismatchHandledSuccessfullyTest()
+        {
+            using TestEnvironment env = TestEnvironment.Create(_output);
+
+            string testProjectPath = Path.Combine(TestAssetsRootPath, "ExampleFrameworkTask", "TestTask", "TestTask.csproj");
+
+            string testTaskOutput = RunnerUtilities.ExecBootstrapedMSBuild($"{testProjectPath} -restore -v:n", out bool successTestTask);
+
+            if (!successTestTask)
+            {
+                _output.WriteLine(testTaskOutput);
+            }
+
+            successTestTask.ShouldBeTrue();
+
+            testTaskOutput.ShouldContain("The task is executed in process: MSBuild");
+            testTaskOutput.ShouldContain("PlatformTarget: x86");
+            testTaskOutput.ShouldContain("PlatformTarget: x64");
+        }
+
+        [WindowsFullFrameworkOnlyFact]
+        public void FrameworkTaskArchitectureMismatchReportsWarningTest()
+        {
+            using TestEnvironment env = TestEnvironment.Create(_output);
+
+            string testProjectPath = Path.Combine(TestAssetsRootPath, "ExampleFrameworkTask", "TestTask", "TestTask.csproj");
+
+            string testTaskOutput = RunnerUtilities.ExecBootstrapedMSBuild($"{testProjectPath} -restore -v:n", out bool successTestTask);
+
+            if (!successTestTask)
+            {
+                _output.WriteLine(testTaskOutput);
+            }
+
+            successTestTask.ShouldBeTrue();
+            testTaskOutput.ShouldContain(ResourceUtilities.FormatResourceStringStripCodeAndKeyword("AssemblyLoad_Warning", "ExampleTaskX64"));
+        }
+    }
+}

src/Build.UnitTests/BackEnd/AssemblyTaskFactory_Tests.cs

@@ -6,6 +6,7 @@
 using System.Reflection;
 using Microsoft.Build.BackEnd;
 using Microsoft.Build.Construction;
+using Microsoft.Build.Engine.UnitTests;
 using Microsoft.Build.Execution;
 using Microsoft.Build.Framework;
 using Microsoft.Build.Shared;
@@ -691,11 +692,12 @@ private void SetupTaskFactory(TaskHostParameters factoryParameters, bool explici
             {
                 factoryParameters = factoryParameters.WithTaskHostFactoryExplicitlyRequested(true);
             }
-            _loadedType = _taskFactory.InitializeFactory(_loadInfo, "TaskToTestFactories", new Dictionary<string, TaskPropertyInfo>(), string.Empty, factoryParameters, explicitlyLaunchTaskHost, null, ElementLocation.Create("NONE"), String.Empty);
+
+            _loadedType = _taskFactory.InitializeFactory(_loadInfo, "TaskToTestFactories", new Dictionary<string, TaskPropertyInfo>(), string.Empty, factoryParameters, explicitlyLaunchTaskHost, new TestLoggingContext(null!, new BuildEventContext(1, 2, 3, 4)), ElementLocation.Create("NONE"), String.Empty);
             Assert.True(_loadedType.Assembly.Equals(_loadInfo)); // "Expected the AssemblyLoadInfo to be equal"
         }
 
-        #endregion
+#endregion
 
         #region InternalClasses
         /// <summary>

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

@@ -8,10 +8,13 @@
 
     <DefineConstants>$(DefineConstants);MICROSOFT_BUILD_ENGINE_UNITTESTS</DefineConstants>
 
-    <!-- Define a constant so we can skip tests that require MSBuildTaskHost -->
+     <!-- Define a constant so we can skip tests that require MSBuildTaskHost -->
     <DefineConstants Condition="'$(MSBuildRuntimeType)' == 'Core'">$(DefineConstants);NO_MSBUILDTASKHOST</DefineConstants>
 
     <CopyLocalLockFileAssemblies>true</CopyLocalLockFileAssemblies>
+
+     <!-- Suppression in needed to build ExampleTaskX86 that targets x86 architecture. -->
+    <NoWarn>$(NoWarn);MSB3270</NoWarn>
   </PropertyGroup>
 
   <ItemGroup>
@@ -125,11 +128,16 @@
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </Content>
   </ItemDefinitionGroup>
-
+  
   <ItemGroup Label="TestAssests" Condition="'$(TargetFrameworkIdentifier)' != '.NETFramework'">
     <ProjectReference Include=".\TestAssets\ExampleNetTask\ExampleTask\ExampleTask.csproj" />
   </ItemGroup>
 
+  <ItemGroup Label="TestAssests" Condition="'$(TargetFrameworkIdentifier)' == '.NETFramework'">
+    <ProjectReference Include=".\TestAssets\ExampleFrameworkTask\ExampleTaskX64\ExampleTaskX64.csproj" />
+    <ProjectReference Include=".\TestAssets\ExampleFrameworkTask\ExampleTaskX86\ExampleTaskX86.csproj" />
+  </ItemGroup>
+
   <ItemGroup>
     <EmbeddedResource Include="TestAssets\ExampleNetTask\TestMSBuildTaskInNet\global.json">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>

src/Build.UnitTests/NetTaskHost_E2E_Tests.cs

@@ -78,7 +78,7 @@ public void NetTaskHost_CorrectPathsEscapingTest()
                 testTaskOutput, 
                 @"Arg\[0\]:\s*(.+)", 
                 System.Text.RegularExpressions.RegexOptions.CultureInvariant);
-            
+
             msBuildDllPathMatch.Success.ShouldBeTrue();
             string msBuildDllPath = msBuildDllPathMatch.Groups[1].Value.Trim();
 
@@ -151,9 +151,17 @@ public void NetTaskWithImplicitHostParamsTest()
             }
 
             successTestTask.ShouldBeTrue();
+
+            // Output from the task where only Runtime was specified
             testTaskOutput.ShouldContain($"The task is executed in process: dotnet");
             testTaskOutput.ShouldContain($"Process path: {dotnetPath}", customMessage: testTaskOutput);
             testTaskOutput.ShouldContain("/nodereuse:True");
+
+            // Output from the task where only TaskHost was specified
+            testTaskOutput.ShouldContain($"Hello TEST FROM MESSAGE");
+
+            // Output from the task where neither TaskHost nor Runtime were specified
+            testTaskOutput.ShouldContain("Found item: Banana");
         }
     }
 }

src/Build.UnitTests/TestAssets/ExampleFrameworkTask/ExampleTaskX64/ExampleTaskX64.cs

@@ -0,0 +1,32 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+using System.Diagnostics;
+using Microsoft.Build.Framework;
+
+namespace SampleTask
+{
+    public class ExampleTaskX64 : Microsoft.Build.Utilities.Task
+    {
+        public string? PlatformTarget { get; set; }
+
+        public override bool Execute()
+        {
+            try
+            {
+                var currentProcess = Process.GetCurrentProcess();
+                var executingProcess = currentProcess.ProcessName;
+                var processPath = currentProcess.MainModule?.FileName ?? "Unknown";
+
+                Log.LogMessage(MessageImportance.High, $"The task is executed in process: {executingProcess}");
+                Log.LogMessage(MessageImportance.High, $"PlatformTarget: {PlatformTarget ?? "Not specified"}");
+
+                return true;
+            }
+            catch (System.Exception ex)
+            {
+                Log.LogError($"Failed to determine executing process: {ex.Message}");
+                return false;
+            }
+        }
+    }
+}

src/Build.UnitTests/TestAssets/ExampleFrameworkTask/ExampleTaskX64/ExampleTaskX64.csproj

@@ -0,0 +1,16 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net472</TargetFramework>
+    <PlatformTarget>x64</PlatformTarget>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Build.Utilities.Core" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageVersion Include="Microsoft.Build.Utilities.Core" Version="17.14.28" />
+  </ItemGroup>
+
+</Project>

src/Build.UnitTests/TestAssets/ExampleFrameworkTask/ExampleTaskX86/ExampleTaskX86.cs

@@ -0,0 +1,32 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+using System.Diagnostics;
+using Microsoft.Build.Framework;
+
+namespace SampleTask
+{
+    public class ExampleTaskX86 : Microsoft.Build.Utilities.Task
+    {
+        public string? PlatformTarget { get; set; }
+
+        public override bool Execute()
+        {
+            try
+            {
+                var currentProcess = Process.GetCurrentProcess();
+                var executingProcess = currentProcess.ProcessName;
+                var processPath = currentProcess.MainModule?.FileName ?? "Unknown";
+
+                Log.LogMessage(MessageImportance.High, $"The task is executed in process: {executingProcess}");
+                Log.LogMessage(MessageImportance.High, $"PlatformTarget: {PlatformTarget ?? "Not specified"}");
+
+                return true;
+            }
+            catch (System.Exception ex)
+            {
+                Log.LogError($"Failed to determine executing process: {ex.Message}");
+                return false;
+            }
+        }
+    }
+}

src/Build.UnitTests/TestAssets/ExampleFrameworkTask/ExampleTaskX86/ExampleTaskX86.csproj

@@ -0,0 +1,16 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net472</TargetFramework>
+    <PlatformTarget>x86</PlatformTarget>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Build.Utilities.Core" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageVersion Include="Microsoft.Build.Utilities.Core" Version="17.14.28" />
+  </ItemGroup>
+
+</Project>

src/Build.UnitTests/TestAssets/ExampleFrameworkTask/TestTask/TestTask.csproj

@@ -0,0 +1,21 @@
+<Project ToolsVersion="msbuilddefaulttoolsversion"  xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+
+  <PropertyGroup>
+    <TargetFramework>net472</TargetFramework>
+  </PropertyGroup>
+
+  <PropertyGroup>
+    <TestProjectFolder>$([System.IO.Path]::GetFullPath('$([System.IO.Path]::Combine('$(AssemblyLocation)', '..'))'))</TestProjectFolder>
+    <ExampleTaskX86Path>$([System.IO.Path]::Combine('$(TestProjectFolder)', '$(TargetFramework)', 'ExampleTaskX86.dll'))</ExampleTaskX86Path>
+    <ExampleTaskX64Path>$([System.IO.Path]::Combine('$(TestProjectFolder)', '$(TargetFramework)', 'ExampleTaskX64.dll'))</ExampleTaskX64Path>
+  </PropertyGroup>
+
+  <UsingTask TaskName="ExampleTaskX86" AssemblyFile="$(ExampleTaskX86Path)"/>
+  <UsingTask TaskName="ExampleTaskX64" AssemblyFile="$(ExampleTaskX64Path)"/>
+
+  <Target Name="TestTask" BeforeTargets="Build">
+    <ExampleTaskX86 PlatformTarget="x86" />
+    <ExampleTaskX64 PlatformTarget="x64" />
+  </Target>
+
+</Project>

src/Build.UnitTests/TestAssets/ExampleNetTask/TestMSBuildTaskInNet/TestMSBuildTaskInNet.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net10.0</TargetFramework>
+    <TargetFrameworks>net10.0</TargetFrameworks>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
   </PropertyGroup>

src/Build.UnitTests/TestAssets/ExampleNetTask/TestNetTaskWithImplicitParams/TestNetTaskWithImplicitParams.csproj

@@ -9,10 +9,35 @@
     <ExampleTaskPath>$([System.IO.Path]::Combine('$(TestProjectFolder)', '$(TargetFramework)', 'ExampleTask.dll'))</ExampleTaskPath>
   </PropertyGroup>
 
-  <UsingTask TaskName="ExampleTask" AssemblyFile="$(ExampleTaskPath)" Runtime="NET"/>
+  <UsingTask TaskName="ExampleTask"
+             AssemblyFile="$(ExampleTaskPath)"
+             Runtime="NET"/>
+
+  <UsingTask TaskName="Microsoft.Build.Tasks.Message"
+             AssemblyFile="$(MSBuildToolsPath)\Microsoft.Build.Tasks.Core.dll"
+             TaskFactory="TaskHostFactory" />
+
+  <UsingTask TaskName="Microsoft.Build.Tasks.FindInList"
+             AssemblyFile="$(MSBuildToolsPath)\Microsoft.Build.Tasks.Core.dll" />
+
+  <ItemGroup>
+    <MyItems Include="Apple" />
+    <MyItems Include="Banana" />
+    <MyItems Include="Cherry" />
+    <MyItems Include="Date" />
+  </ItemGroup>
 
   <Target Name="TestTask" BeforeTargets="Build">
     <ExampleTask />
+
+    <Message Text="Hello TEST FROM MESSAGE" Importance="high" />
+
+    <FindInList List="@(MyItems)"
+                ItemSpecToFind="Banana"
+                CaseSensitive="false">
+      <Output TaskParameter="ItemFound" PropertyName="FoundItem"/>
+    </FindInList>
+    <Message Text="Found item: $(FoundItem)" Importance="high" Condition="'$(FoundItem)' != ''" />
   </Target>
 
 </Project>

src/Build/BackEnd/TaskExecutionHost/TaskExecutionHost.cs

@@ -425,7 +425,7 @@ public bool SetTaskParameters(IDictionary<string, (string, ElementLocation)> par
                 }
             }
 
-            if (this.TaskInstance is IIncrementalTask incrementalTask)
+            if (TaskInstance is IIncrementalTask incrementalTask)
             {
                 incrementalTask.FailIfNotIncremental = _buildComponentHost.BuildParameters.Question;
             }