Reference a solution project from multiple other projects with a different Platform

[ArcanoxDragon]

I am writing a Source Generator project in my company's solution, and it needs to reference another low-level shared library from the same solution. I will call that the Core project. Most of the solution projects explicitly compile using the x64 Platform (we define <Platforms>x64</Platforms> in Directory.Build.props). The Core project overrides this and defines <Platforms>x64;AnyCPU</Platforms>.

The Source Generator project itself needs to be able to run on ARM64 processors (e.g. if building something on ARM64 Mac devices that will utilize the generator), so it explicitly sets <Platforms>AnyCPU</Platforms> and only ever targets AnyCPU. It should, therefore, reference the AnyCPU version of Core. I have tried to accomplish this as follows:

<ItemGroup>
	<ProjectReference Include="Path\To\Core\Core.csproj">
		<SetConfiguration>Configuration=Debug</SetConfiguration>
		<SetConfiguration Condition="'$(Configuration)' == 'Release'">Configuration=Release</SetConfiguration>
		<SetPlatform>Platform=AnyCPU</SetPlatform>
	</ProjectReference>
</ItemGroup>

However, when building the solution (from Visual Studio or command line), I see the following warning:

warning MSB3270: There was a mismatch between the processor architecture of the project being built "MSIL" and the processor architecture of the reference "C:\Git\Path\To\Core\bin\x64\Debug\netstandard2.0\Core.dll", "AMD64". This mismatch may cause runtime failures. Please consider changing the targeted processor architecture of your project through the Configuration Manager so as to align the processor architectures between your project and references, or take a dependency on references with a processor architecture that matches the targeted processor architecture of your project.

I used the MSBuild Structured Log Viewer to see what was happening, and it looks like the AssignProjectConfiguration task is overriding SetConfiguration, SetPlatform, Configuration, Platform, and FullConfiguration to use whatever Configuration/Platform mapping is defined for the Core project in the solution file.

Obviously I don't want to use that mapping, as I'm explicitly setting SetPlatform and SetConfiguration to something else - I'm not sure why MSBuild just ignores that entirely.

I tried the following hack just to see if it would fix the problem:

<Target Name="FixCoreConfigurationAndPlatform"
		AfterTargets="AssignProjectConfiguration">
	<ItemGroup>
		<_ProjectReferenceWithConfiguration>
			<SetConfiguration Condition="$([System.String]::new('%(_ProjectReferenceWithConfiguration.Identity)').Contains('Core.csproj'))">Configuration=Debug</SetConfiguration>
			<SetPlatform Condition="$([System.String]::new('%(_ProjectReferenceWithConfiguration.Identity)').Contains('Core.csproj'))">Platform=AnyCPU</SetPlatform>
			<Configuration Condition="$([System.String]::new('%(_ProjectReferenceWithConfiguration.Identity)').Contains('Core.csproj'))">Debug</Configuration>
			<Platform Condition="$([System.String]::new('%(_ProjectReferenceWithConfiguration.Identity)').Contains('Core.csproj'))">AnyCPU</Platform>
			<FullConfiguration Condition="$([System.String]::new('%(_ProjectReferenceWithConfiguration.Identity)').Contains('Core.csproj'))">Debug|AnyCPU</FullConfiguration>
		</_ProjectReferenceWithConfiguration>
		<ProjectReferenceWithConfiguration>
			<SetConfiguration Condition="$([System.String]::new('%(ProjectReferenceWithConfiguration.Identity)').Contains('Core.csproj'))">Configuration=Debug</SetConfiguration>
			<SetPlatform Condition="$([System.String]::new('%(ProjectReferenceWithConfiguration.Identity)').Contains('Core.csproj'))">Platform=AnyCPU</SetPlatform>
			<Configuration Condition="$([System.String]::new('%(ProjectReferenceWithConfiguration.Identity)').Contains('Core.csproj'))">Debug</Configuration>
			<Platform Condition="$([System.String]::new('%(ProjectReferenceWithConfiguration.Identity)').Contains('Core.csproj'))">AnyCPU</Platform>
			<FullConfiguration Condition="$([System.String]::new('%(ProjectReferenceWithConfiguration.Identity)').Contains('Core.csproj'))">Debug|AnyCPU</FullConfiguration>
		</ProjectReferenceWithConfiguration>
	</ItemGroup>
</Target>

This actually works on command line! Even if I fully clean the solution (remove all the bin and obj folders), it will build the Core project using the normal Solution configuration (Debug|x64 or whatever), and then right before it builds the Source Generator project, it will build Core again using the Debug|AnyCPU configuration. The Source Generator project consumes the correct version of the DLL (from bin\Debug instead of bin\x64\Debug).

Unfortunately, however, this solution does not work inside Visual Studio. If I remove the bin and obj folders and then try to build the solution inside Visual Studio, I get a build error from the Source Generator project:

error CS0006: Metadata file 'C:\Git\Path\To\Core\obj\Debug\netstandard2.0\ref\Core.dll' could not be found

I used the instructions here to produce a binary log of Visual Studio's specific invocation of MSBuild to see what was different. I narrowed it down to the following:

msbuild/src/Tasks/Microsoft.Common.CurrentVersion.targets

Lines 2120 to 2168 in ce25c01

	<Target
	Name="ResolveProjectReferences"
	DependsOnTargets="PrepareProjectReferences"
	Returns="@(_ResolvedNativeProjectReferencePaths);@(_ResolvedProjectReferencePaths)">
	<!--
	When building this project from the IDE, just gather the referenced build outputs.
	The IDE will already have built the project, so there's no need to do it again here.
	The ContinueOnError setting is here so that, during project load, as
	much information as possible will be passed to the compilers.
	-->
	<MSBuild
	Projects="@(_MSBuildProjectReferenceExistent)"
	Targets="GetTargetPath"
	BuildInParallel="$(BuildInParallel)"
	Properties="%(_MSBuildProjectReferenceExistent.SetConfiguration); %(_MSBuildProjectReferenceExistent.SetPlatform); %(_MSBuildProjectReferenceExistent.SetTargetFramework)"
	Condition="'%(_MSBuildProjectReferenceExistent.BuildReference)' == 'true' and '@(ProjectReferenceWithConfiguration)' != '' and ('$(BuildingInsideVisualStudio)' == 'true' or '$(BuildProjectReferences)' != 'true') and '$(VisualStudioVersion)' != '10.0' and '@(_MSBuildProjectReferenceExistent)' != ''"
	ContinueOnError="!$(BuildingProject)"
	RemoveProperties="%(_MSBuildProjectReferenceExistent.GlobalPropertiesToRemove)$(_GlobalPropertiesToRemoveFromProjectReferences)">
	<Output TaskParameter="TargetOutputs" ItemName="_ResolvedProjectReferencePaths"
	Condition="'%(_MSBuildProjectReferenceExistent.ReferenceOutputAssembly)'=='true'" />
	<Output TaskParameter="TargetOutputs"
	ItemName="%(_MSBuildProjectReferenceExistent.OutputItemType)"
	Condition="'%(_MSBuildProjectReferenceExistent.OutputItemType)' != ''" />
	</MSBuild>
	<!--
	Build referenced projects when building from the command line.
	-->
	<MSBuild
	Projects="@(_MSBuildProjectReferenceExistent)"
	Targets="%(_MSBuildProjectReferenceExistent.Targets)"
	BuildInParallel="$(BuildInParallel)"
	Properties="%(_MSBuildProjectReferenceExistent.SetConfiguration); %(_MSBuildProjectReferenceExistent.SetPlatform); %(_MSBuildProjectReferenceExistent.SetTargetFramework)"
	Condition="'%(_MSBuildProjectReferenceExistent.BuildReference)' == 'true' and '@(ProjectReferenceWithConfiguration)' != '' and '$(BuildingInsideVisualStudio)' != 'true' and '$(BuildProjectReferences)' == 'true' and '@(_MSBuildProjectReferenceExistent)' != ''"
	ContinueOnError="$(ContinueOnError)"
	RemoveProperties="%(_MSBuildProjectReferenceExistent.GlobalPropertiesToRemove)$(_GlobalPropertiesToRemoveFromProjectReferences)">
	<Output TaskParameter="TargetOutputs" ItemName="_ResolvedProjectReferencePaths"
	Condition="'%(_MSBuildProjectReferenceExistent.ReferenceOutputAssembly)'=='true' or '$(DesignTimeBuild)' == 'true'" />
	<Output TaskParameter="TargetOutputs"
	ItemName="%(_MSBuildProjectReferenceExistent.OutputItemType)"
	Condition="'%(_MSBuildProjectReferenceExistent.OutputItemType)' != ''" />
	</MSBuild>

It seems like it explicitly skips building the project if the build is invoked from Visual Studio:

Condition="... and '$(BuildingInsideVisualStudio)' != 'true' and ..."

Is there a way to actually accomplish what I am trying to accomplish? I don't want to use a bunch of custom MSBuild stuff for this (e.g. I don't want to do anything along the lines of manually invoking MSBuild tasks to force-build the project or anything like that).

It would be great if I could just do something with the solution configuration mappings so that it always builds both the x64 and AnyCPU platforms for the Core project, but it doesn't seem like that's possible.

I can potentially change the Core project so that it always targets AnyCPU, but it would be deviating from the expectation that ALL of our other projects up to this point have referenced its x64 DLL. Even if that ends up being the route I take, it would be nice to know how to solve the original problem in case I ever encounter this situation again where the other projects must have architecture-specific target platforms (e.g. native AOT or something).