Directory.Build.props

<Project>

  <PropertyGroup>
    <AccelerateBuildsInVisualStudio>true</AccelerateBuildsInVisualStudio>
  </PropertyGroup>

  <PropertyGroup>
    <!-- $(RepoRoot) is normally set globally and Arcade overrides it to ensure a trailing slash. -->
    <RepoRoot Condition=" '$(RepoRoot)' == '' OR !HasTrailingSlash('$(RepoRoot)') ">$(MSBuildThisFileDirectory)</RepoRoot>

    <RepositoryUrl>https://github.com/dotnet/aspnetcore</RepositoryUrl>
    <RepositoryType>git</RepositoryType>
  </PropertyGroup>

  <PropertyGroup>
    <EnableNETAnalyzers>true</EnableNETAnalyzers>
    <AnalysisLevel>latest</AnalysisLevel>
    <AnalysisMode>Default</AnalysisMode>
  </PropertyGroup>

  <!-- Defines project type conventions. -->
  <PropertyGroup>
    <RepoRelativeProjectDir>$([MSBuild]::MakeRelative($(RepoRoot), $(MSBuildProjectDirectory)))</RepoRelativeProjectDir>

    <IsBenchmarkProject Condition=" $(MSBuildProjectName.EndsWith('.Performance')) OR
        $(RepoRelativeProjectDir.Contains('perf')) OR
        $(RepoRelativeProjectDir.Contains('benchmarkapps')) ">true</IsBenchmarkProject>
    <IsMicrobenchmarksProject Condition=" $(MSBuildProjectName.EndsWith('.Microbenchmarks')) ">true</IsMicrobenchmarksProject>
    <IsSpecificationTestProject Condition="$(MSBuildProjectName.EndsWith('.Specification.Tests'))">true</IsSpecificationTestProject>
    <IsUnitTestProject Condition=" '$(IsUnitTestProject)' == '' AND
        '$(IsSpecificationTestProject)' != 'true' AND
        ( $(MSBuildProjectName.EndsWith('Tests')) OR
          $(MSBuildProjectName.EndsWith('.Test')) OR
          $(MSBuildProjectName.EndsWith('.FunctionalTest')) ) ">true</IsUnitTestProject>
    <IsUnitTestProject Condition=" '$(IsUnitTestProject)' == '' ">false</IsUnitTestProject>
    <IsTrimmingTestProject Condition="$(MSBuildProjectName.EndsWith('.TrimmingTests'))">true</IsTrimmingTestProject>
    <IsNativeAotTestProject Condition="$(MSBuildProjectName.EndsWith('.NativeAotTests'))">true</IsNativeAotTestProject>
    <IsPublishedAppTestProject Condition="'$(IsTrimmingTestProject)' == 'true' or '$(IsNativeAotTestProject)' == 'true'">true</IsPublishedAppTestProject>
    <IsTestAssetProject Condition=" $(RepoRelativeProjectDir.Contains('testassets')) OR $(MSBuildProjectName.Contains('TestCommon'))">true</IsTestAssetProject>
    <IsProjectTemplateProject Condition=" ($(RepoRelativeProjectDir.Contains('ProjectTemplates')) OR $(MSBuildProjectName.Contains('ProjectTemplates')) ) AND
        '$(IsUnitTestProject)' != 'true' AND
        '$(IsTestAssetProject)' != 'true' ">true</IsProjectTemplateProject>
    <IsSampleProject Condition=" $(RepoRelativeProjectDir.ToUpperInvariant().Contains('SAMPLE')) ">true</IsSampleProject>
    <IsAnalyzersProject Condition="$(MSBuildProjectName.EndsWith('.Analyzers'))">true</IsAnalyzersProject>
    <IsShipping Condition=" '$(IsSampleProject)' == 'true' OR
        '$(IsTestAssetProject)' == 'true' OR
        '$(IsBenchmarkProject)' == 'true' OR
        '$(IsPublishedAppTestProject)' == 'true' OR
        $(IsUnitTestProject) ">false</IsShipping>
  </PropertyGroup>

  <!-- Disable logging of some task parameters or metadata to reduce binlog size.
       Reenable logging of any particular item by changing the value of the property below to 'false'
       The format is as follows:
       DisableLogTaskParameter_[task name]_[parameter name] - Disable logging of a particular parameter
       DisableLogTaskParameterItemMetadata_[task name]_[parameter name] - Disable logging of item metadata of the parameter
  -->
  <PropertyGroup>
    <TrimTaskParameters Condition=" '$(TrimTaskParameters)' == '' ">true</TrimTaskParameters>
    <!-- ItemsToHash is used for incremental building and hashes input properties to a file
         This is not generally useful for day-to-day build debugging. -->
    <DisableLogTaskParameter_Hash_ItemsToHash>$(TrimTaskParameters)</DisableLogTaskParameter_Hash_ItemsToHash>

    <!-- JoinItems takes input ItemGroups. The output ItemGroup is logged. -->
    <DisableLogTaskParameter_JoinItems_Right>$(TrimTaskParameters)</DisableLogTaskParameter_JoinItems_Right>
    <DisableLogTaskParameter_JoinItems_Left>$(TrimTaskParameters)</DisableLogTaskParameter_JoinItems_Left>

    <!-- ConvertToAbsolutePaths - The output parameter (AbsolutePaths) is interesting
         while the input Path is not generally useful. The output itemgroup's metadata
         is not altered by the task. -->
    <DisableLogTaskParameter_ConvertToAbsolutePath_Paths>$(TrimTaskParameters)</DisableLogTaskParameter_ConvertToAbsolutePath_Paths>
    <DisableLogTaskParameterItemMetadata_ConvertToAbsolutePath_Paths>$(TrimTaskParameters)</DisableLogTaskParameterItemMetadata_ConvertToAbsolutePath_Paths>

    <!-- The standard msbuild Copy task does not use Metadata and thus the input/outputs
         item metadata is not relevant -->
     <DisableLogTaskParameterItemMetadata_Copy_SourceFiles>$(TrimTaskParameters)</DisableLogTaskParameterItemMetadata_Copy_SourceFiles>
     <DisableLogTaskParameterItemMetadata_Copy_DestinationFiles>$(TrimTaskParameters)</DisableLogTaskParameterItemMetadata_Copy_DestinationFiles>

     <!-- Reference metadata for GenerateDepsFile, Csc, RAR, etc. are sometimes useful, but extraordinarily large
          when building against a shared framework where the number of input assemblies is very large.
          Avoid logging these by default. -->
     <DisableLogTaskParameterItemMetadata_GenerateDepsFile_ReferenceAssemblies>$(TrimTaskParameters)</DisableLogTaskParameterItemMetadata_GenerateDepsFile_ReferenceAssemblies>
     <DisableLogTaskParameterItemMetadata_GenerateDepsFile_ReferencePaths>$(TrimTaskParameters)</DisableLogTaskParameterItemMetadata_GenerateDepsFile_ReferencePaths>
     <DisableLogTaskParameterItemMetadata_ResolveAssemblyReference_Assemblies>$(TrimTaskParameters)</DisableLogTaskParameterItemMetadata_ResolveAssemblyReference_Assemblies>
     <DisableLogTaskParameterItemMetadata_Csc_References>$(TrimTaskParameters)</DisableLogTaskParameterItemMetadata_Csc_References>
  </PropertyGroup>

  <Import Project="eng\QuarantinedTests.BeforeArcade.props" />
  <Import Project="Sdk.props" Sdk="Microsoft.DotNet.Arcade.Sdk" />
  <Import Project="eng\QuarantinedTests.AfterArcade.props" />
  <Import Project="eng\Common.props" />

  <PropertyGroup>
    <Product>Microsoft ASP.NET Core</Product>
    <StrongNameKeyId>MicrosoftAspNetCore</StrongNameKeyId>

    <!-- The SPDX name for the source license. See https://spdx.org/licenses/. -->
    <PackageLicenseExpression>MIT</PackageLicenseExpression>

    <!-- Contact email address for NuGet packages and Linux installers. -->
    <MaintainerEmail>nugetaspnet@microsoft.com</MaintainerEmail>

    <PackageProjectUrl>https://asp.net</PackageProjectUrl>
    <NuspecBasePath>$(MSBuildProjectDirectory)</NuspecBasePath>

    <IncludeSymbols>true</IncludeSymbols>
    <DefaultNetFxTargetFramework>net462</DefaultNetFxTargetFramework>
  </PropertyGroup>

  <!-- Warnings and errors -->
  <PropertyGroup>
    <!-- Ensure API docs are available. -->
    <NoWarn>$(NoWarn.Replace('1591', ''))</NoWarn>
    <NoWarn Condition=" '$(BuildingInsideVisualStudio)' == 'true' ">$(NoWarn);0105</NoWarn>
    <!-- Allow prerelease dependencies in stable packages when we're running the IdentityModel nightly tests -->
    <NoWarn Condition=" '$(IsIdentityModelTestJob)' == 'true' ">$(NoWarn);NU5104</NoWarn>

    <!-- For local builds, don't make missing XML docs a fatal build error, but still surface so we have visibility into undocumented APIs. -->
    <WarningsNotAsErrors Condition=" '$(ContinuousIntegrationBuild)' != 'true' ">$(WarningsNotAsErrors);CS1591</WarningsNotAsErrors>

    <!-- xUnit1004 = warns about skipped tests. Make this a non-fatal build warning. -->
    <WarningsNotAsErrors>$(WarningsNotAsErrors);xUnit1004</WarningsNotAsErrors>

    <!-- don't warn about calling ConfigureAwait in test methods. we already commonly get off the xunit threads because they cause issues. -->
    <NoWarn>$(NoWarn);xUnit1030</NoWarn>

    <!-- don't warn about unnecessary trim warning suppressions. can be removed with preview 6. -->
    <NoWarn>$(NoWarn);IL2121</NoWarn>

    <!-- // Temporary diagnostic code from https://github.com/dotnet/extensions/pull/4130 for metrics APIs used in test. -->
    <NoWarn>$(NoWarn);TBD</NoWarn>
  </PropertyGroup>

  <!-- Source code settings -->
  <PropertyGroup>
    <SharedSourceRoot>$(MSBuildThisFileDirectory)src\Shared\</SharedSourceRoot>
    <GoogleTestSubmoduleRoot>$(RepoRoot)src\submodules\googletest\</GoogleTestSubmoduleRoot>

    <!-- Embed source files that are not tracked by the source control manager in the PDB. -->
    <EmbedUntrackedSources>true</EmbedUntrackedSources>
  </PropertyGroup>

  <PropertyGroup>
    <SharedFxName>Microsoft.AspNetCore.App</SharedFxName>
    <SharedFxDescription>Shared Framework for hosting of Microsoft ASP.NET Core applications. It is open source, cross-platform and is supported by Microsoft. We hope you enjoy using it! If you do, please consider joining the active community of developers that are contributing to the project on GitHub ($(RepositoryUrl)). We happily accept issues and PRs.</SharedFxDescription>

    <NETCoreAppFrameworkIdentifier>.NETCoreApp</NETCoreAppFrameworkIdentifier>
    <NETCoreAppFramework>netcoreapp$(AspNetCoreMajorMinorVersion)</NETCoreAppFramework>
    <AspNetCoreAppFrameworkBrandName>ASP.NET Core $(AspNetCoreMajorMinorVersion)</AspNetCoreAppFrameworkBrandName>

    <TargetingPackName>Microsoft.AspNetCore.App.Ref</TargetingPackName>
    <RuntimeInstallerBaseName>aspnetcore-runtime</RuntimeInstallerBaseName>
    <TargetingPackInstallerBaseName>aspnetcore-targeting-pack</TargetingPackInstallerBaseName>
  </PropertyGroup>

  <!-- Compilation options which apply to all languages. Language-specific options should be set in eng/targets/$(lang).Common.props -->
  <PropertyGroup>
    <BuildArchitecture>$([System.Runtime.InteropServices.RuntimeInformation]::ProcessArchitecture.ToString().ToLowerInvariant())</BuildArchitecture>

    <!-- This defines the list of RIDs supported by the ASP.NET Core shared framework.
         The list is a semicolon separated list of RIDs. Whitespace may not be added to the property. -->
    <SupportedRuntimeIdentifiers>win-x64;win-x86;win-arm;win-arm64;osx-x64;osx-arm64;linux-musl-x64;linux-musl-arm;linux-musl-arm64;linux-x64;linux-arm;linux-arm64;freebsd-x64</SupportedRuntimeIdentifiers>
    <SupportedRuntimeIdentifiers Condition=" '$(DotNetBuildSourceOnly)' == 'true' ">$(SupportedRuntimeIdentifiers);$(TargetRuntimeIdentifier)</SupportedRuntimeIdentifiers>

    <!-- Playwright provides binaries for Windows (x86 and x64), macOS (x64) and Linux (x64, non musl). We can't use it on other architectures. -->
    <IsPlaywrightAvailable Condition="'$(TargetOsName)' == 'linux-musl' OR ('$(TargetArchitecture)' != 'x86' AND '$(TargetArchitecture)' != 'x64')">false</IsPlaywrightAvailable>
    <IsPlaywrightAvailable Condition="'$(IsPlaywrightAvailable)' == ''">true</IsPlaywrightAvailable>

    <!-- Make error messages clickable in VS Code's console -->
    <GenerateFullPaths Condition="'$(VSCODE_CWD)' != '' OR '$(TERM_PROGRAM)' == 'vscode'">true</GenerateFullPaths>

    <!-- Fixes a common error in targets implementing a NoBuild mode. -->
    <BuildProjectReferences Condition=" '$(NoBuild)' == 'true' ">false</BuildProjectReferences>
  </PropertyGroup>

  <!-- Artifacts layout. Keep these values consistent with items defined in eng/Publishing.props. -->
  <PropertyGroup>
    <InstallersOutputPath>$(ArtifactsDir)installers\$(Configuration)\</InstallersOutputPath>
    <SymbolsOutputPath>$(ArtifactsDir)symbols\$(Configuration)\</SymbolsOutputPath>
  </PropertyGroup>

  <!-- Ensure these output paths exist. -->
  <ItemGroup>
    <CreateDirectory Include="$(InstallersOutputPath)" />
    <CreateDirectory Include="$(VisualStudioSetupOutputPath)" />
  </ItemGroup>

  <!-- The location of the local installation of the .NET Core shared framework. -->
  <PropertyGroup>
    <LocalDotNetRoot>$(RepoRoot).dotnet\</LocalDotNetRoot>
    <LocalDotNetRoot Condition="'$(DotNetBuild)' == 'true'">DontDareMutateThisSDK</LocalDotNetRoot>

    <!--
      Override the SDK default and point to local .dotnet folder. This is done to work around
      limitations in the way the .NET SDK finds shared frameworks and targeting packs. It allows
      tests to use the shared frameworks and targeting packs that were just built.

      However, source-build needs this to not happen while building projects that rely on the
      AppHost framework pack. Source-build installs an SDK in a custom location outside this
      repository, and setting NetCoreTargetingPackRoot to a different location causes source-build
      to restore the AppHost pack as a prebuilt rather than using the one that's present in the SDK.
      Source-build doesn't run tests, so the property is simply conditioned out.
    -->
    <NetCoreTargetingPackRoot Condition="'$(DotNetBuild)' != 'true'">$(LocalDotNetRoot)packs\</NetCoreTargetingPackRoot>
    <!-- This is not correct and needs attention eventually. This is primarily used to find the nethost headers in the apphost pack.
         These should be coming from a restored apphost pack, rather than a hard-coded local SDK. In fact, aspnetcore
         should not rely on a local SDK or mutating one to build. -->
    <NetCoreTargetingPackRoot Condition="'$(DotNetBuild)' == 'true'">$(DotNetRoot)packs\</NetCoreTargetingPackRoot>

  </PropertyGroup>

  <Import Project="eng\tools\RepoTasks\RepoTasks.tasks" Condition="'$(MSBuildProjectName)' != 'RepoTasks' AND '$(DesignTimeBuild)' != 'true'" />

  <PropertyGroup>
    <!--
      Disable deterministic source paths in test assets and samples.
      In order for the debugger to find source files when debugging a locally built binary the PDB must contain original, unmapped local paths
    -->
    <DeterministicSourcePaths Condition="'$(IsSampleProject)' == 'true' OR '$(IsTestAssetProject)' == 'true'">false</DeterministicSourcePaths>
    <!-- Projects which reference Microsoft.AspNetCore.Mvc.Testing should import this targets file to ensure dependency .deps.json files are copied into test output. -->
    <MvcTestingTargets>$(MSBuildThisFileDirectory)src\Mvc\Mvc.Testing\src\Microsoft.AspNetCore.Mvc.Testing.targets</MvcTestingTargets>
    <_MvcTestingTasksAssembly>$(ArtifactsBinDir)\Microsoft.AspNetCore.Mvc.Testing.Tasks\$(Configuration)\netstandard2.0\Microsoft.AspNetCore.Mvc.Testing.Tasks.dll</_MvcTestingTasksAssembly>
    <!-- IIS native projects can only be built on Windows for x86/x64/ARM64. -->
    <UseIisNativeAssets Condition=" '$(TargetOsName)' == 'win' AND ('$(TargetArchitecture)' == 'x86' OR '$(TargetArchitecture)' == 'x64' OR '$(TargetArchitecture)' == 'ARM64') ">true</UseIisNativeAssets>
    <!-- This property is shared by several projects to layout the AspNetCore.App targeting pack for installers -->
    <TargetingPackLayoutRoot>$(ArtifactsObjDir)TargetingPack.Layout\$(Configuration)\</TargetingPackLayoutRoot>
    <!-- This property is shared by several projects to layout the AspNetCore.App shared framework for installers -->
    <SharedFrameworkLayoutRoot>$(ArtifactsObjDir)SharedFx.Layout\$(Configuration)\$(TargetRuntimeIdentifier)\</SharedFrameworkLayoutRoot>
    <!-- This property points to a folder which includes both Microsoft.NETCore.App and AspNetCore.App. -->
    <RedistSharedFrameworkLayoutRoot>$(ArtifactsObjDir)RedistSharedFx.Layout\$(Configuration)\$(TargetRuntimeIdentifier)\</RedistSharedFrameworkLayoutRoot>

    <ArchiveExtension>.tar.gz</ArchiveExtension>
    <ArchiveExtension Condition="'$(TargetOsName)' == 'win'">.zip</ArchiveExtension>
  </PropertyGroup>

  <PropertyGroup>
    <OfficialBaseURL>https://dotnetcli.azureedge.net/dotnet/</OfficialBaseURL>
    <!-- Allow overriding the public base URL for Unified Build scenarios to pull assets from a local build. -->
    <PublicBaseURL Condition="'$(PublicBaseURL)' == ''">https://dotnetbuilds.azureedge.net/public/</PublicBaseURL>
    <InternalBaseURL>https://dotnetbuilds.azureedge.net/internal/</InternalBaseURL>
    <!-- Allow overriding where installers are pulled in from previously completed jobs in Unified Build scenarios. -->
    <CrossArchitectureInstallerBasePath Condition="'$(CrossArchitectureInstallerBasePath)' == ''">$(ArtifactsShippingPackagesDir)</CrossArchitectureInstallerBasePath>
  </PropertyGroup>

  <!-- Try various places to find the runtime. It's either released (use official version),
        public but un-released (use dotnetbuilds/public), or internal and unreleased (use dotnetbuilds/internal) -->
  <ItemGroup Condition="'$(DotNetBuild)' != 'true'">
    <RemoteAssetBaseURL Include="$(OfficialBaseURL)" />
    <RemoteAssetBaseURL Include="$(PublicBaseURL)" />
    <!-- Include the token here as we'll generate the URLs to download based on this item group. -->
    <RemoteAssetBaseURL Include="$(InternalBaseURL)"
                        Condition=" '$(DotnetRuntimeSourceFeedKey)' != '' ">
      <token>$(DotnetRuntimeSourceFeedKey)</token>
    </RemoteAssetBaseURL>
  </ItemGroup>

  <!--
    Only try downloading from the "public" base URL when doing a vertical build.
    In a vertical build, the public URL will be overwritten to point to local build artifacts.
  -->
  <ItemGroup Condition="'$(DotNetBuild)' == 'true'">
    <!-- MSBuild removes the '//' slashes when passing PublicBaseURL from the outer to the inner build. -->
    <RemoteAssetBaseURL Condition="$(PublicBaseURL.StartsWith('file:')) and '$(OS)' != 'Windows_NT'" Include="$([System.Text.RegularExpressions.Regex]::Replace('$(PublicBaseURL)', '%28file:\/{1,}%29%28.+%29', 'file:///%242'))" />
    <RemoteAssetBaseURL Condition="!$(PublicBaseURL.StartsWith('file:')) or '$(OS)' == 'Windows_NT'" Include="$(PublicBaseURL)" />
  </ItemGroup>

  <PropertyGroup>
    <!-- PackageReadmeFile specifies the package readme file name in the package. PackageReadmeFilePath points to the package readme file on disk. -->
    <EnableDefaultPackageReadmeFile Condition="'$(EnableDefaultPackageReadmeFile)' == '' and '$(IsShipping)' != 'false'">true</EnableDefaultPackageReadmeFile>
    <PackageReadmeFilePath Condition="'$(PackageReadmeFilePath)' == '' and '$(EnableDefaultPackageReadmeFile)' == 'true'">PACKAGE.md</PackageReadmeFilePath>
    <PackageReadmeFile Condition="'$(PackageReadmeFile)' == '' and '$(EnableDefaultPackageReadmeFile)' == 'true' and Exists('$(PackageReadmeFilePath)' )">PACKAGE.md</PackageReadmeFile>
  </PropertyGroup>

  <!-- Add a package README file -->
  <ItemGroup Condition="'$(PackageReadmeFilePath)' != '' and Exists('$(PackageReadmeFilePath)' )">
    <None Include="$(PackageReadmeFilePath)" Pack="true" PackagePath="\" />
  </ItemGroup>

  <PropertyGroup>
    <!-- Set the arcade before common targets so we compute ExcludeFromBuild before arcade uses it. -->
    <CustomBeforeMicrosoftCommonTargets>$(MSBuildThisFileDirectory)Directory.Build.BeforeCommonTargets.targets</CustomBeforeMicrosoftCommonTargets>
    <CustomBeforeMicrosoftCommonCrossTargetingTargets>$(MSBuildThisFileDirectory)Directory.Build.BeforeCommonTargets.targets</CustomBeforeMicrosoftCommonCrossTargetingTargets>
  </PropertyGroup>

  <Import Project="eng\Workarounds.props" />
  <Import Project="artifacts\bin\GenerateFiles\Directory.Build.props" Condition=" '$(MSBuildProjectName)' != 'GenerateFiles' " />
  <Import Project="eng\Dependencies.props" />
  <Import Project="eng\ProjectReferences.props" />
  <Import Project="eng\RequiresDelayedBuildProjects.props" />
  <Import Project="eng\SharedFramework.Local.props" />
  <Import Project="eng\SharedFramework.External.props" />
  <Import Project="eng\ShippingAssemblies.props" />
  <Import Project="eng\targets\Cpp.Common.props"  Condition="'$(MSBuildProjectExtension)' == '.vcxproj'" />
  <Import Project="eng\targets\CSharp.Common.props"  Condition="'$(MSBuildProjectExtension)' == '.csproj'" />
  <Import Project="eng\targets\Wix.Common.props"  Condition="'$(MSBuildProjectExtension)' == '.wixproj'" />
  <Import Project="eng\targets\Java.Common.props"  Condition="'$(MSBuildProjectExtension)' == '.javaproj'" />
  <Import Project="eng\testing\linker\trimmingTests.props" Condition="'$(IsPublishedAppTestProject)' == 'true'" />
  <Import Project="eng\targets\Helix.props" Condition=" $(IsTestProject) " />
  <Import Project="eng\targets\FunctionalTestWithAssets.props" Condition=" $(IsTestProject) " />

  <!-- Keys used by InternalsVisibleTo attributes. -->
  <PropertyGroup>
    <MoqPublicKey>0024000004800000940000000602000000240000525341310004000001000100c547cac37abd99c8db225ef2f6c8a3602f3b3606cc9891605d02baa56104f4cfc0734aa39b93bf7852f7d9266654753cc297e7d2edfe0bac1cdcf9f717241550e0a7b191195b7667bb4f64bcb8e2121380fd1d9d46ad2d92d2d15605093924cceaf74c4861eff62abf69b9291ed0a340e113be11e6a7d3113e92484cf7045cc7</MoqPublicKey>
  </PropertyGroup>
</Project>