Directory.Build.props

<Project TreatAsLocalProperty="ExcludeRestorePackageImports">
  <!-- Base repo layout properties -->
  <PropertyGroup>
    <RepoRoot>$(MSBuildThisFileDirectory)</RepoRoot>
    <RepositoryEngineeringDir>$(RepoRoot)eng\</RepositoryEngineeringDir>
    <RepositoryUrl>git://github.com/dotnet/corefx</RepositoryUrl>
  </PropertyGroup>

  <PropertyGroup>
    <!--
    For non-SDK projects that import this file and then import Microsoft.Common.props,
    tell Microsoft.Common.props not to import Directory.Build.props again
    -->
    <ImportDirectoryBuildProps>false</ImportDirectoryBuildProps>

    <!-- We use the compiler toolset that comes from NuGet Packages rather than the SDK built-in.
    This one sets UseSharedCompilation to false by default. -->
    <UseSharedCompilation>true</UseSharedCompilation>

    <ToolSetCommonDirectory>$(MSBuildThisFileDirectory)artifacts\toolset\Common\</ToolSetCommonDirectory>
    <IsSourceProject Condition="$([System.Text.RegularExpressions.Regex]::IsMatch($(MSBuildProjectDirectory), 'src%24'))">true</IsSourceProject>
  </PropertyGroup>

  <!-- Define vNext UAP Moniker -->
  <PropertyGroup>
    <UAPvNextVersion>10.0.16300</UAPvNextVersion>
    <UAPvNextTFI>UAP</UAPvNextTFI>
    <UAPvNextTFMFull>$(UAPvNextTFI),Version=v$(UAPvNextVersion)</UAPvNextTFMFull>
    <UAPvNextTFM>uap$(UAPvNextVersion)</UAPvNextTFM>
  </PropertyGroup>

  <!-- Import configuration data model -->
  <Import Project="$(RepositoryEngineeringDir)configurations/properties.props" />
  
  <PropertyGroup Condition="'$(BuildingInsideVisualStudio)' == 'true' and '$(Configuration)' != ''">
    <!-- When building in VS setup the ConfigurationGroup based on the given Configuration -->
    <ConfigurationGroup Condition="$(Configuration.EndsWith('Debug'))">Debug</ConfigurationGroup>
    <ConfigurationGroup Condition="$(Configuration.EndsWith('Release'))">Release</ConfigurationGroup>
  </PropertyGroup>
  
  <!-- Platform detection -->
  <PropertyGroup>
    <DefaultOSGroup Condition="'$(OS)'=='Unix' AND Exists('/Applications')">OSX</DefaultOSGroup>
    <DefaultOSGroup Condition="'$(DefaultOSGroup)'=='' AND '$(OS)'=='Unix' AND $([MSBuild]::IsOSPlatform('FREEBSD'))">FreeBSD</DefaultOSGroup>
    <DefaultOSGroup Condition="'$(DefaultOSGroup)'=='' AND '$(OS)'=='Unix' AND $([MSBuild]::IsOSPlatform('NETBSD'))">NetBSD</DefaultOSGroup>
    <DefaultOSGroup Condition="'$(DefaultOSGroup)'=='' AND '$(OS)'=='Unix'">Linux</DefaultOSGroup>
    <DefaultOSGroup Condition="'$(DefaultOSGroup)'==''">$(OS)</DefaultOSGroup>
  </PropertyGroup>

  <PropertyGroup>
    <!--
      These *Group properties are only intended to enable passing them individually at the command line to initialize
      BuildConfiguration. They will be overwritten by our configurations/configuration.props file and defaulted
      based on Configuration for the individual projects which is selected based on BuildConfiguration.

      See Documentation/coding-guidelines/project-guidelines.md for more details on our configurations.
    -->
    <TargetGroup Condition="'$(TargetGroup)' == ''">netcoreapp</TargetGroup>
    <OSGroup Condition="'$(OSGroup)' == ''">$(DefaultOSGroup)</OSGroup>
    <ConfigurationGroup Condition="'$(ConfigurationGroup)' == ''">Debug</ConfigurationGroup>
    <HostArch>$([System.Runtime.InteropServices.RuntimeInformation]::ProcessArchitecture)</HostArch>
    <ArchGroup Condition="'$(ArchGroup)' == '' AND '$(HostArch)' == 'Arm'">arm</ArchGroup>
    <ArchGroup Condition="'$(ArchGroup)' == '' AND '$(HostArch)' == 'Arm64'">arm64</ArchGroup>
    <ArchGroup Condition="'$(ArchGroup)' == ''">x64</ArchGroup>

    <!-- Initialize BuildConfiguration from the individual properties if it wasn't already explicitly set -->
    <BuildConfiguration Condition="'$(BuildConfiguration)' == ''">$(TargetGroup)-$(OSGroup)-$(ConfigurationGroup)-$(ArchGroup)</BuildConfiguration>

    <!-- if PKGPROJ doesn't set BuildConfigurations, make sure it only builds for TargetGroup=package or BuildAllConfigurations -->
    <BuildConfigurations Condition="'$(MSBuildProjectExtension)' == '.pkgproj' AND '$(BuildConfigurations)' == ''">package</BuildConfigurations>
  </PropertyGroup>


  <!-- Informs build tools to apply .NET Framework metadata if not a test project -->
  <PropertyGroup>
    <IsDotNetFrameworkProductAssembly>true</IsDotNetFrameworkProductAssembly>
  </PropertyGroup>

  <!-- Indicates this is not an officially supported release. Release branches should set this to false. -->
  <PropertyGroup>
    <IsPrerelease>true</IsPrerelease>
  </PropertyGroup>

  <!-- Provides package dependency version properties and verification/auto-upgrade configuration -->
  <Import Project="$(RepositoryEngineeringDir)dependencies.props" />

  <PropertyGroup>
    <!-- Need to set ProjectAssetsFile to something so it doesn't get set to the Tools.proj assets file when we import the generated props -->
    <ProjectAssetsFile Condition="'$(ProjectAssetsFile)' == ''">unused</ProjectAssetsFile>
    <!-- Nuget will normally disable all generated imports as part of a restore to avoid 
         non-determinism where first restore changes a subsequent restore,
         but we need these since they define properties (like TargetFramework) needed by restore.
         In this case we garuntee this is ok since these specific props are not restored by this project's restore. -->
    <_excludeRestorePackageImports>$(ExcludeRestorePackageImports)</_excludeRestorePackageImports>
    <ExcludeRestorePackageImports>false</ExcludeRestorePackageImports>
  </PropertyGroup>
  <Import Project="$(ToolSetCommonDirectory)Tools.proj.nuget.g.props" Condition="Exists('$(ToolSetCommonDirectory)Tools.proj.nuget.g.props')" />
  <PropertyGroup>
    <ProjectAssetsFile Condition="'$(ProjectAssetsFile)' == 'unused'"></ProjectAssetsFile>
    <ExcludeRestorePackageImports>$(_excludeRestorePackageImports)</ExcludeRestorePackageImports>
  </PropertyGroup>

  <!-- Common repo directories -->
  <PropertyGroup>
    <ArtifactsBinDir>$([MSBuild]::NormalizeDirectory('$(RepoRoot)', 'artifacts', 'bin'))</ArtifactsBinDir>
    
    <!-- Need to try and keep the same logic as the native builds as we need this for packaging -->
    <NativeBinDir>$([MSBuild]::NormalizePath('$(ArtifactsBinDir)', 'native', '$(BuildConfiguration)'))</NativeBinDir>

    <!-- Use msbuild path functions as that property is used in bash scripts. -->
    <SourceDir>$([MSBuild]::NormalizeDirectory('$(RepoRoot)', 'src'))</SourceDir>

    <!-- Input Directories -->
    <PackagesDir>$(DotNetRestorePackagesPath)</PackagesDir>
    <PackagesDir Condition="'$(PackagesDir)'=='' AND '$(NuGetPackageRoot)' != ''">$([MSBuild]::EnsureTrailingSlash('$(NuGetPackageRoot)'))</PackagesDir>
    <PackagesDir Condition="'$(PackagesDir)'==''">$(RepoRoot).packages/</PackagesDir>
    <!-- Respect environment variable for the .NET install directory if set; otherwise, use the current default location -->
    <DotNetRoot Condition="'$(DotNetRoot)' == ''">$(DOTNET_INSTALL_DIR)</DotNetRoot>
    <DotNetRoot Condition="'$(DotNetRoot)' == ''">$(RepoRoot).dotnet\</DotNetRoot>
    <DotNetRoot Condition="!HasTrailingSlash('$(DotNetRoot)')">$(DotNetRoot)\</DotNetRoot>
    <DotnetCliPath Condition="'$(DotnetCliPath)'==''">$(DotNetRoot)</DotnetCliPath>
    <ToolHostCmd Condition="'$(ToolHostCmd)'==''">"$(DotNetRoot)dotnet"</ToolHostCmd>
    <DotNetCmd>$(DotNetRoot)dotnet</DotNetCmd>
    <DotNetCmd Condition="'$(OS)' == 'Windows_NT'">$(DotNetCmd).exe</DotNetCmd>
  </PropertyGroup>

  <!-- workaround https://github.com/dotnet/sdk/issues/2288
       remove once we have a new CLI -->
  <PropertyGroup>
    <LanguageTargets Condition="'$(LanguageTargets)' == '' AND '$(MSBuildProjectExtension)' != '.csproj' AND '$(MSBuildProjectExtension)' != '.vbproj' AND '$(MSBuildProjectExtension)' != '.fsproj'">$(MSBuildToolsPath)\Microsoft.Common.targets</LanguageTargets>
  </PropertyGroup>

  <!-- Enable the analyzers for this repo -->
  <PropertyGroup>
    <EnableAnalyzers Condition="'$(EnableAnalyzers)' == '' AND '$(IsSourceProject)' == 'true'">true</EnableAnalyzers>
  </PropertyGroup>

  <!-- Default properties for CI builds -->
  <PropertyGroup Condition="'$(IsTestProject)' == 'true' and '$(ContinuousIntegrationBuild)' == 'true' and '$(OfficialBuildId)' == ''">
    <WithoutCategories>IgnoreForCI</WithoutCategories>
    <EnableDumpling>false</EnableDumpling>
    <CrashDumpFolder Condition="'$(OS)' == 'Windows_NT'">%TMP%\CoreRunCrashDumps</CrashDumpFolder>
  </PropertyGroup>

  <!-- list of nuget package sources passed to nuget restore -->
  <!-- Example to consume local CoreCLR package:
       /p:OverridePackageSource=C:\coreclr\bin\Product\Windows_NT.x64.Debug\.nuget\pkg
       -->
  <PropertyGroup>
    <RestoreSources Condition="'$(DotNetBuildOffline)' != 'true'">
      https://dotnetfeed.blob.core.windows.net/dotnet-core/index.json;
      https://dotnetfeed.blob.core.windows.net/dotnet-coreclr/index.json;
      https://dotnet.myget.org/F/dotnet-buildtools/api/v3/index.json;
      https://dotnet.myget.org/F/dotnet-core/api/v3/index.json;
      https://api.nuget.org/v3/index.json;
      $(OverridePackageSource);
      $(RestoreSources)
    </RestoreSources>
  </PropertyGroup>

  <PropertyGroup>
    <!-- By default make all libraries to be AnyCPU but individual projects can override it if they need to -->
    <Platform>AnyCPU</Platform>
    <OutputType>Library</OutputType>
    <!-- Default any assembly not specifying a key to use the Open Key -->
    <StrongNameKeyId>Open</StrongNameKeyId>
    <RunApiCompat Condition="'$(TargetGroup)' != 'netcoreappaot'">true</RunApiCompat>
    <ApiCompatExcludeAttributeList>$(RepositoryEngineeringDir)DefaultGenApiDocIds.txt</ApiCompatExcludeAttributeList>
    <!-- Build as portable by default -->
    <PortableBuild Condition="'$(PortableBuild)' == ''">true</PortableBuild>
    <!-- Used for launchSettings.json and runtime config files. -->
    <AppDesignerFolder>Properties</AppDesignerFolder>
  </PropertyGroup>

  <PropertyGroup>
    <_runtimeOSVersionIndex>$(RuntimeOS.IndexOfAny(".-0123456789"))</_runtimeOSVersionIndex>
    <_runtimeOSFamily Condition="'$(_runtimeOSVersionIndex)' != '-1'">$(RuntimeOS.SubString(0, $(_runtimeOSVersionIndex)))</_runtimeOSFamily>
    <_portableOS>linux</_portableOS>
    <_portableOS Condition="'$(RuntimeOS)' == 'linux-musl'">linux-musl</_portableOS>
    <_portableOS Condition="'$(_runtimeOSFamily)' == 'win' OR '$(OSGroup)' == 'Windows_NT'">win</_portableOS>
    <_portableOS Condition="'$(_runtimeOSFamily)' == 'osx'">osx</_portableOS>
    <_portableOS Condition="'$(_runtimeOSFamily)' == 'FreeBSD'">freebsd</_portableOS>
    <_portableOS Condition="'$(RuntimeOS)' == 'WebAssembly'">webassembly</_portableOS>

    <_runtimeOS>$(RuntimeOS)</_runtimeOS>
    <_runtimeOS Condition="'$(_runtimeOS)' == 'tizen.4.0.0'">linux</_runtimeOS>
    <_runtimeOS Condition="'$(_runtimeOS)' == 'tizen.5.0.0'">linux</_runtimeOS>
    <_runtimeOS Condition="'$(PortableBuild)' == 'true'">$(_portableOS)</_runtimeOS>
    <ToolRuntimeRID>$(_runtimeOS)-x64</ToolRuntimeRID>
    <!-- We build linux-musl-arm on a ubuntu container, so we can't use the toolset build for alpine runtime. We need to use portable linux RID for our toolset in order to be able to use it. -->
    <ToolRuntimeRID Condition="'$(_runtimeOS)' == 'linux-musl' AND $(ArchGroup.StartsWith('arm')) AND !$(HostArch.StartsWith('Arm'))">linux-x64</ToolRuntimeRID>

    <!-- There are no WebAssembly tools, so treat them as Windows -->
    <ToolRuntimeRID Condition="'$(RuntimeOS)' == 'WebAssembly'">win-x64</ToolRuntimeRID>

    <!-- support cross-targeting by choosing a RID to restore when running on a different machine that what we're build for -->
    <_portableOS Condition="'$(OSGroup)' == 'Unix' AND '$(_runtimeOSFamily)' != 'osx' AND '$(_runtimeOSFamily)' != 'FreeBSD' AND '$(_runtimeOS)' != 'linux-musl'">linux</_portableOS>

    <_packageRID/>
    <_packageRID Condition="'$(PortableBuild)' == 'true'">$(_portableOS)-$(ArchGroup)</_packageRID>
    <_packageRID Condition="$(TargetGroup.StartsWith('uap'))">win10-$(ArchGroup)</_packageRID>
    <_packageRID Condition="$(TargetGroup.EndsWith('aot'))">$(_packageRID)-aot</_packageRID>
    <PackageRID Condition="'$(PackageRID)' == ''">$(_packageRID)</PackageRID>
    <PackageRID Condition="'$(PackageRID)' == ''">$(RuntimeOS)-$(ArchGroup)</PackageRID>
  </PropertyGroup>

  <!-- Set some shortcuts for more terse conditions in project files -->
  <PropertyGroup>
    <TargetsNetCoreApp Condition="$(TargetGroup.StartsWith('netcoreapp'))">true</TargetsNetCoreApp>
    <TargetsUap Condition="$(TargetGroup.StartsWith('uap'))">true</TargetsUap>
    <TargetsAot Condition="$(TargetGroup.EndsWith('aot'))">true</TargetsAot>
    <TargetsNetStandard Condition="$(TargetGroup.StartsWith('netstandard'))">true</TargetsNetStandard>
    <TargetsNetFx Condition="$(TargetGroup.StartsWith('net4')) OR '$(TargetGroup)' == 'netfx'">true</TargetsNetFx>
  </PropertyGroup>

  <!-- set properties for each vertical -->
  <PropertyGroup>
    <BuildingNETCoreAppVertical Condition="'$(BuildingNETCoreAppVertical)' == '' AND ('$(_bc_TargetGroup)'=='netcoreapp' OR '$(_bc_TargetGroup)'=='netcoreappaot' OR '$(BuildAllConfigurations)' == 'true')">true</BuildingNETCoreAppVertical>
    <BuildingNETStandardVertical Condition="'$(BuildingNETStandardVertical)' == '' AND ('$(_bc_TargetGroup)'=='netstandard' OR '$(BuildAllConfigurations)' == 'true')">true</BuildingNETStandardVertical>
    <BuildingNETFxVertical Condition="'$(BuildingNETFxVertical)' == '' AND ('$(_bc_TargetGroup)'=='netfx' OR '$(BuildAllConfigurations)' == 'true')">true</BuildingNETFxVertical>
    <BuildingUAPVertical Condition="'$(BuildingUAPVertical)' == '' AND ('$(_bc_TargetGroup)'=='uap' OR '$(BuildAllConfigurations)' == 'true')">true</BuildingUAPVertical>
    <BuildingUAPAOTVertical Condition="'$(BuildingUAPAOTVertical)' == '' AND ('$(_bc_TargetGroup)'=='uapaot' OR '$(BuildAllConfigurations)' == 'true')">true</BuildingUAPAOTVertical>
  </PropertyGroup>

  <!--
    Import the arcade sdk with these requirements.
    After:
      Configuration setup

    Before:
      DebugType needs to be not be set to embedded at least for facades
      OutputPath setup
  -->
  <PropertyGroup>
    <DisableArcadeTestFramework>true</DisableArcadeTestFramework>
  </PropertyGroup>

  <Import Project="Sdk.props" Sdk="Microsoft.DotNet.Arcade.Sdk" />
  
  <PropertyGroup Condition="'$(CopyrightNetFoundation)' != ''">
    <Copyright>$(CopyrightNetFoundation)</Copyright>
    <!-- Temporarily disable PackageLicenseExpression until we can workaround 
         https://github.com/NuGet/Home/issues/7894 -->
    <!-- PackageLicenseExpression>MIT</PackageLicenseExpression -->
  </PropertyGroup>

  <!-- Import packaging props -->
  <Import Project="$(RepositoryEngineeringDir)Packaging.props"/>

  <!-- Set the kind of PDB to Portable and turn on SourceLink (fetching source from GitHub) -->
  <PropertyGroup>
    <!-- Always pass portable to override arcade sdk which uses embedded for local builds -->
    <DebugType>portable</DebugType>

    <!-- Empty DebugType when building for netfx and in windows so that it is set to full or pdbonly later -->
    <DebugType Condition="'$(TargetsNetFx)' == 'true' AND '$(OS)' == 'Windows_NT'"></DebugType>

    <!-- Rhel 6 and FreeBSD doesn't support the source control git package so disable SourceLink -->
    <EnableSourceLink Condition="$(RuntimeOS.StartsWith('rhel.6')) OR '$(_runtimeOSFamily)' == 'FreeBSD'">false</EnableSourceLink>
    <!-- is not supported on ARM platforms either. -->
    <EnableSourceLink Condition="'$(HostArch)' == 'Arm' OR '$(HostArch)' == 'Arm64'">false</EnableSourceLink>
    <!-- Disable source link on local builds. -->
    <EnableSourceLink Condition="'$(ContinuousIntegrationBuild)' != 'true' and '$(OfficialBuildId)' == ''">false</EnableSourceLink>
  </PropertyGroup>
  
  <PropertyGroup>
    <!-- Embed IBC data on Windows release builds, if IBCMerge isn't available this will just log the commandline -->
    <EnablePartialNgenOptimization Condition="'$(EnablePartialNgenOptimization)' == '' and '$(OS)' == 'Windows_NT' and '$(ConfigurationGroup)' == 'Release'">true</EnablePartialNgenOptimization>
  </PropertyGroup>

  <!-- Set up Default symbol and optimization for Configuration -->
  <Choose>
    <When Condition="'$(ConfigurationGroup)'=='Debug'">
      <PropertyGroup>
        <DebugSymbols Condition="'$(DebugSymbols)' == ''">true</DebugSymbols>
        <Optimize Condition="'$(Optimize)' == ''">false</Optimize>
        <DebugType Condition="'$(DebugType)' == ''">full</DebugType>
        <DefineConstants>$(DefineConstants),DEBUG,TRACE</DefineConstants>
      </PropertyGroup>
    </When>
    <When Condition="'$(ConfigurationGroup)' == 'Release'">
      <PropertyGroup>
        <DebugSymbols Condition="'$(DebugSymbols)' == ''">true</DebugSymbols>
        <Optimize Condition="'$(Optimize)' == ''">true</Optimize>
        <DebugType Condition="'$(DebugType)' == ''">pdbonly</DebugType>
        <DefineConstants>$(DefineConstants),TRACE</DefineConstants>
      </PropertyGroup>
    </When>
  </Choose>

  <!-- Disable some standard properties for building our projects -->
  <PropertyGroup>
    <NoStdLib>true</NoStdLib>
    <NoExplicitReferenceToStdLib>true</NoExplicitReferenceToStdLib>
    <AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
    <GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
    <CopyNuGetImplementations>false</CopyNuGetImplementations>
    <!-- Don't reference implicit framework packages, all projects in this repo must be explicit -->
    <DisableImplicitFrameworkReferences>true</DisableImplicitFrameworkReferences>
  </PropertyGroup>

  <!-- Language configuration -->
  <PropertyGroup>
    <!-- default to allowing all language features -->
    <LangVersion>latest</LangVersion>
    <LangVersion Condition="'$(Language)' == 'C#'">preview</LangVersion>
    <!-- Enables Strict mode for Roslyn compiler -->
    <Features>strict</Features>
    <WarningLevel>4</WarningLevel>
    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>

    <!-- We cannot enable deterministic builds yet but we would like to in the future see https://github.com/dotnet/corefx/issues/2003 -->
    <Deterministic>false</Deterministic>

    <!-- We decided to keep this disabled by default to see some history of way have a look at https://github.com/dotnet/corefx/issues/3140 -->
    <CheckForOverflowUnderflow>false</CheckForOverflowUnderflow>

    <!-- Suppress preview message as we are usually using preview SDK versions. -->
    <SuppressNETCoreSdkPreviewMessage>true</SuppressNETCoreSdkPreviewMessage>
    
    <CLSCompliant Condition="'$(CLSCompliant)'=='' and '$(IsTestProject)'=='true'">false</CLSCompliant>
    <CLSCompliant Condition="'$(CLSCompliant)'==''">true</CLSCompliant>
    <GenFacadesIgnoreBuildAndRevisionMismatch>true</GenFacadesIgnoreBuildAndRevisionMismatch>
    
    <!-- Warnings -->
    <NoWarn>$(NoWarn);BCL0020</NoWarn> <!-- TODO: Remove BCL0020 once https://github.com/dotnet/arcade/pull/2158 is consumed. -->
  </PropertyGroup>

  <!-- Set up some common paths -->
  <PropertyGroup>
    <CommonPath>$(SourceDir)Common\src</CommonPath>
    <CommonTestPath>$(SourceDir)Common\tests</CommonTestPath>
  </PropertyGroup>

  <!-- Set up the default output and intermediate paths -->
  <PropertyGroup>
    <!--
      Microsoft.NET.TargetFrameworkInference.targets appends the TargetFramework.
      We do this manually and use the TargetGroup instead.
    -->
    <AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>

    <TargetOutputRelPath Condition="'$(TargetGroup)'!=''">$(TargetGroup)/</TargetOutputRelPath>

    <RuntimePath Condition="'$(RuntimePath)' == ''">$(ArtifactsBinDir)runtime/$(BuildConfiguration)/</RuntimePath>
    <TestWorkingDir Condition="'$(TestWorkingDir)'==''">$([MSBuild]::NormalizeDirectory('$(ArtifactsBinDir)', 'tests'))</TestWorkingDir>
    <TestPath Condition="'$(TestPath)' == ''">$([MSBuild]::NormalizeDirectory('$(TestWorkingDir)', '$(MSBuildProjectName)', '$(BuildConfiguration)'))</TestPath>
    <RefRootPath>$(ArtifactsBinDir)ref/</RefRootPath>
    <BuildConfigurationRefPath>$(RefRootPath)$(_bc_TargetGroup)/</BuildConfigurationRefPath>
    <BuildConfigurationRefPath Condition="$(_bc_TargetGroup.EndsWith('aot'))">$(RefRootPath)$(_bc_TargetGroup.TrimEnd('aot'))/</BuildConfigurationRefPath>
    <RefPath>$(RefRootPath)$(TargetGroup)/</RefPath>
    <RefPath Condition="$(TargetGroup.EndsWith('aot'))">$(RefRootPath)$(TargetGroup.TrimEnd('aot'))/</RefPath>
    <NetStandardRefPath>$(RefRootPath)netstandard/</NetStandardRefPath>
    <NetStandard21RefPath>$(RefRootPath)netstandard2.1/</NetStandard21RefPath>
    <NetFxRefPath>$(RefRootPath)netfx/</NetFxRefPath>
    <GlobalToolsDir>$([MSBuild]::NormalizeDirectory('$(ArtifactsDir)', 'tools'))</GlobalToolsDir>
    <IbcOptimizationDataDir>$([MSBuild]::NormalizeDirectory('$(ArtifactsDir)', 'ibc'))</IbcOptimizationDataDir>
    <ILAsmToolPath>$([MSBuild]::NormalizeDirectory('$(ArtifactsToolsetDir)', 'ilasm'))</ILAsmToolPath>
    <ILLinkDir>$([MSBuild]::NormalizeDirectory('$(ArtifactsToolsetDir)', 'ILLink'))</ILLinkDir>

    <!-- Helix properties -->
    <OSPlatformConfig>$(OSGroup).$(Platform).$(ConfigurationGroup)</OSPlatformConfig>
    <AnyOSPlatformConfig>AnyOS.AnyCPU.$(ConfigurationGroup)</AnyOSPlatformConfig>
    <UnixPlatformConfig>Unix.$(Platform).$(ConfigurationGroup)</UnixPlatformConfig>
    <TestArchiveRoot>$(ArtifactsDir)helix/</TestArchiveRoot>
    <TestArchiveTestsRoot>$(TestArchiveRoot)tests/</TestArchiveTestsRoot>
    <TestArchiveTestsDir>$(TestArchiveTestsRoot)$(OSPlatformConfig)/</TestArchiveTestsDir>
    <TestArchiveRuntimeRoot>$(TestArchiveRoot)runtime/</TestArchiveRuntimeRoot>

    <!-- project file to use when resolving ReferenceFromRuntime items -->
    <RuntimeProjectFile Condition="'$(RuntimeProjectFile)' == ''">$(RepoRoot)\external\runtime\runtime.depproj</RuntimeProjectFile>

    <!-- Paths to binplace package content -->
    <NETCoreAppPackageRefPath>$(ArtifactsBinDir)pkg\netcoreapp\ref</NETCoreAppPackageRefPath>
    <NETCoreAppPackageRuntimePath>$(ArtifactsBinDir)pkg\netcoreapp\lib</NETCoreAppPackageRuntimePath>
    <NETCoreAppAotPackageRuntimePath>$(ArtifactsBinDir)pkg\netcoreappaot\lib</NETCoreAppAotPackageRuntimePath>
    <UAPPackageRefPath>$(ArtifactsBinDir)pkg\uap\ref</UAPPackageRefPath>
    <UAPPackageRuntimePath>$(ArtifactsBinDir)pkg\uap\lib</UAPPackageRuntimePath>
    <UAPAOTPackageRuntimePath>$(ArtifactsBinDir)pkg\uapaot\lib</UAPAOTPackageRuntimePath>
    <NetFxPackageRefPath>$(ArtifactsBinDir)pkg\netfx\ref</NetFxPackageRefPath>
    <NetFxPackageRuntimePath>$(ArtifactsBinDir)pkg\netfx\lib</NetFxPackageRuntimePath>
    <NETStandardTestSuiteOutputPath>$(ArtifactsBinDir)NetStandardTestSuite\</NETStandardTestSuiteOutputPath>

    <!-- We add extra binplacing for the test shared framework until we can get hardlinking with the runtime directory working on all platforms -->
    <BinPlaceTestSharedFramework Condition="'$(_bc_TargetGroup)' == 'netcoreapp' AND '$(BuildTests)'!='false'">true</BinPlaceTestSharedFramework>
    <BinPlaceILCInputFolder Condition="$(_bc_TargetGroup.EndsWith('aot')) And '$(BinPlaceILCInputFolder)' == ''">true</BinPlaceILCInputFolder>
    <BinPlaceUAPFramework Condition="'$(_bc_TargetGroup)' == 'uap'">true</BinPlaceUAPFramework>
    <BinPlaceNETFXRuntime Condition="'$(_bc_TargetGroup)' == 'netfx'">true</BinPlaceNETFXRuntime>

    <NETCoreAppTestSharedFxVersion>9.9.9</NETCoreAppTestSharedFxVersion>
    <TestHostRootPath>$([MSBuild]::NormalizeDirectory('$(ArtifactsBinDir)', 'testhost', '$(BuildConfiguration)'))</TestHostRootPath>
    <NETCoreAppTestHostFxrPath>$([MSBuild]::NormalizeDirectory('$(TestHostRootPath)', 'host', 'fxr', '$(NETCoreAppTestSharedFxVersion)'))</NETCoreAppTestHostFxrPath>
    <NETCoreAppTestSharedFrameworkPath>$([MSBuild]::NormalizeDirectory('$(TestHostRootPath)', 'shared', 'Microsoft.NETCore.App', '$(NETCoreAppTestSharedFxVersion)'))</NETCoreAppTestSharedFrameworkPath>
    <ILCFXInputFolder>$(TestHostRootPath)ILCInputFolder</ILCFXInputFolder>
    <InternalTestILCFolder>$(TestHostRootPath)TestILC</InternalTestILCFolder>

    <!-- For UAP, we'll produce the layout and hard-link this into each test's directory -->
    <UAPTestSharedFrameworkPath>$(TestHostRootPath)UAPLayout</UAPTestSharedFrameworkPath>

    <!-- Constructed shared fx path for testing -->
    <UseDotNetNativeToolchain Condition="$(_bc_TargetGroup.EndsWith('aot'))">true</UseDotNetNativeToolchain>
    <!-- System.Private.* comes from test ilc, so the symbol packages for those versions will no exist, this is to avoid warnings -->
    <DownloadCoreCLRSymbols Condition="'$(UseDotNetNativeToolchain)' == 'true' OR '$(BuildAllConfigurations)' == 'true' OR '$(DotNetBuildFromSource)' == 'true'">false</DownloadCoreCLRSymbols>

    <!-- interop is not available on NETStandard1.0 -->
    <IncludeDllSafeSearchPathAttribute Condition="'$(TargetGroup)' == 'netstandard1.0'">false</IncludeDllSafeSearchPathAttribute>

    <VersionFileForPackages Condition="'$(VersionFileForPackages)' == ''">$(ArtifactsObjDir)version.txt</VersionFileForPackages>
  </PropertyGroup>

  <!--
    Remove test-only dependencies during source-build: disable project that brings in XUnit.Runtime
    dependencies through 'ReferenceFromRuntime' property.
  -->
  <ItemGroup Condition="'$(DotNetBuildFromSource)' == 'true' and '$(BuildTests)' != 'true'">
    <ProjectExclusions Include="$(SourceDir)CoreFx.Private.TestUtilities/**/*.csproj" />
  </ItemGroup>

  <!-- Properties related to multi-file mode for ILC tests -->
  <PropertyGroup Condition="'$(TargetGroup)' == 'uapaot'">
    <!-- Only enable multi-file for Release-x64 and Debug-x86 for now -->
    <!-- Temporarily disabling multifile test configurations. For more info, please check: https://github.com/dotnet/corefx/issues/22826
    <EnableMultiFileILCTests Condition="'$(ConfigurationGroup)|$(ArchGroup)' == 'Release|x64' Or '$(ConfigurationGroup)|$(ArchGroup)' == 'Debug|x86' Or '$(ConfigurationGroup)|$(ArchGroup)' == 'Release|arm'">true</EnableMultiFileILCTests> -->
  </PropertyGroup>

  <!-- Specify the default constants for each target group -->
  <PropertyGroup>
    <DefineConstants Condition="'$(TargetGroup)' == 'uap'">$(DefineConstants),uap</DefineConstants>
    <DefineConstants Condition="'$(TargetGroup)' == 'uapaot'">$(DefineConstants),uapaot</DefineConstants>
    <DefineConstants Condition="'$(TargetGroup)' == 'netfx'">$(DefineConstants),netfx</DefineConstants>
    <DefineConstants Condition="'$(TargetGroup)' == 'netstandard'">$(DefineConstants),netstandard</DefineConstants>
    <DefineConstants Condition="'$(TargetGroup)' == 'netcoreapp'">$(DefineConstants),netcoreapp</DefineConstants>
    <DefineConstants Condition="'$(TargetGroup)' == 'netcoreapp2.0'">$(DefineConstants),netcoreapp20</DefineConstants>
  </PropertyGroup>

  <PropertyGroup>
    <!-- Don't run tests if we're building another platform's binaries on Windows -->
    <SkipTests Condition="'$(SkipTests)' == '' and ('$(OsEnvironment)'=='Windows_NT' and '$(TargetsWindows)'!='true' and '$(OSGroup)'!='AnyOS')">true</SkipTests>

    <!-- F5 and debugging support for netcoreapp and netfx inside VS. -->
    <EnableLaunchSettings Condition="'$(EnableLaunchSettings)' == ''AND '$(DotNetBuildFromSource)' != 'true'">true</EnableLaunchSettings>

    <!-- Disable VS Test SDK references if the .NET Native toolchain is used. -->
    <EnableVSTestReferences Condition="'$(UseDotNetNativeToolchain)' == 'true'">false</EnableVSTestReferences>
    <EnableVSTestReferences Condition="'$(EnableVSTestReferences)' == ''">true</EnableVSTestReferences>
  </PropertyGroup>

  <!-- Test properties for full build. -->
  <PropertyGroup Condition="'$(BuildAllProjects)' == 'true'">
    <GenerateFullCoverageReport Condition="'$(GenerateFullCoverageReport)' == ''">true</GenerateFullCoverageReport>
  </PropertyGroup>

  <Import Condition="'$(IsTestProject)' == 'true' AND '$(IsTestSupportProject)' != 'true' AND '$(EnableVSTestReferences)' == 'true'" Project="$(RuntimePath)Microsoft.NET.Test.Sdk.props" />

  <ItemDefinitionGroup Condition="'$(IsTestProject)' != 'true'"> 
    <!-- Project references for non-test assemblies should never be copied to the output. -->
    <ProjectReference>
      <Private>false</Private>
    </ProjectReference>
  </ItemDefinitionGroup>

  <!-- Import it at the end of the props file to override the OutputPath for reference assemblies and use common directory props -->
  <Import Project="$(RepositoryEngineeringDir)ReferenceAssemblies.props" />

  <PropertyGroup Condition="'$(IsSourceProject)' == 'true'">
    <!-- Set the documentation output file globally. -->
    <DocumentationFile Condition="'$(DocumentationFile)' == ''">$(OutputPath)$(MSBuildProjectName).xml</DocumentationFile>
  </PropertyGroup>

  <!-- Additional optimizations -->
  <PropertyGroup>
    <!-- Clear the init locals flag on all src projects, except those in VB, where we can't use spans. -->
    <ILLinkClearInitLocals Condition="'$(IsSourceProject)' == 'true' AND '$(Language)' != 'VB'">true</ILLinkClearInitLocals>
  </PropertyGroup>

</Project>