[platform/core/dotnet/build-tools.git] /

<!--\r
***********************************************************************************************\r
Microsoft.NET.Sdk.DefaultItems.targets\r
\r
WARNING:  DO NOT MODIFY this file unless you are knowledgeable about MSBuild and have\r
          created a backup copy.  Incorrect changes to this file will make it\r
          impossible to load or build your projects from the command-line or the IDE.\r
\r
Copyright (c) .NET Foundation. All rights reserved. \r
***********************************************************************************************\r
-->\r
<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">\r
\r
  <PropertyGroup>\r
    <MSBuildAllProjects>$(MSBuildAllProjects);$(MSBuildThisFileFullPath)</MSBuildAllProjects>\r
  </PropertyGroup>\r
\r
  <PropertyGroup>\r
   <EnableDefaultItems Condition=" '$(EnableDefaultItems)' == '' ">true</EnableDefaultItems>\r
   <EnableDefaultCompileItems Condition=" '$(EnableDefaultCompileItems)' == '' ">true</EnableDefaultCompileItems>\r
    <EnableDefaultEmbeddedResourceItems Condition=" '$(EnableDefaultEmbeddedResourceItems)' == '' ">true</EnableDefaultEmbeddedResourceItems>\r
    <EnableDefaultNoneItems Condition=" '$(EnableDefaultNoneItems)' == '' ">true</EnableDefaultNoneItems>\r
  </PropertyGroup>\r
\r
  <PropertyGroup>    \r
    <!-- Set DefaultItemExcludes property for items that should be excluded from the default Compile, etc items.\r
         This is in the .targets because it needs to come after the final BaseOutputPath has been evaluated. -->\r
    \r
    <!-- bin folder, by default -->\r
    <DefaultItemExcludes>$(DefaultItemExcludes);$(BaseOutputPath)/**</DefaultItemExcludes>\r
    <!-- obj folder, by default -->\r
    <DefaultItemExcludes>$(DefaultItemExcludes);$(BaseIntermediateOutputPath)/**</DefaultItemExcludes>\r
\r
    <!-- Various files that should generally always be ignored -->\r
    <DefaultItemExcludes>$(DefaultItemExcludes);**/*.user</DefaultItemExcludes>\r
    <DefaultItemExcludes>$(DefaultItemExcludes);**/*.*proj</DefaultItemExcludes>\r
    <DefaultItemExcludes>$(DefaultItemExcludes);**/*.sln</DefaultItemExcludes>\r
    <DefaultItemExcludes>$(DefaultItemExcludes);**/*.vssscc</DefaultItemExcludes>\r
    \r
    <!-- WARNING: This pattern is there to ignore folders such as .git and .vs, but it will also match items included with a\r
         relative path outside the project folder (for example "..\Shared\Shared.cs").  So be sure only to apply it to items\r
         that are in the project folder. -->\r
    <DefaultExcludesInProjectFolder>$(DefaultItemExcludesInProjectFolder);**/.*/**</DefaultExcludesInProjectFolder>\r
\r
    <!-- TODO: Verify why this was originally added and whether we really need it -->\r
    <DefaultItemExcludes>$(DefaultItemExcludes);packages/**</DefaultItemExcludes>\r
    \r
  </PropertyGroup>\r
\r
  <!-- Set the default versions of the NETStandard.Library or Microsoft.NETCore.App packages to reference.\r
       The implicit package references themselves are defined in Microsoft.NET.Sdk.props, so that they can be overridden\r
       in the project file. -->\r
  <PropertyGroup Condition="'$(TargetFrameworkIdentifier)' == '.NETStandard'">\r
    <!-- If targeting the same release that is bundled with the .NET Core SDK, use the bundled package version provided by Microsoft.NETCoreSdk.BundledVersions.props -->\r
    <NETStandardImplicitPackageVersion Condition="'$(NETStandardImplicitPackageVersion)' =='' And '$(_TargetFrameworkVersionWithoutV)' == '$(BundledNETStandardTargetFrameworkVersion)'">$(BundledNETStandardPackageVersion)</NETStandardImplicitPackageVersion>\r
\r
    <!-- If targeting .NET Standard 1.x, use version 1.6.1 of the package.  This is so that when projects are packed, the dependency on the package produced won't change when\r
         updating to the 2.0 or higher SDK.  When targeting .NET Standard 2.0 or higher, the NETStandard.Library reference won't show up as a dependency of the package\r
         produced, so we will roll forward to the latest version. -->\r
    <NETStandardImplicitPackageVersion Condition="'$(NETStandardImplicitPackageVersion)' =='' And '$(_TargetFrameworkVersionWithoutV)' &lt; '2.0'">1.6.1</NETStandardImplicitPackageVersion>\r
    \r
    <!-- Default to use the latest stable release.  Currently this is the same as the previous clause, but when we have a stable 2.0 package this should change. -->\r
    <NETStandardImplicitPackageVersion Condition="'$(NETStandardImplicitPackageVersion)' ==''">1.6.1</NETStandardImplicitPackageVersion>\r
  </PropertyGroup>\r
  \r
  <!--  \r
    Determine the RuntimeFrameworkVersion when targeting .NET Core\r
    \r
    When targeting .NET Core, the TargetFramework is generally used to specify which version of the runtime to use.\r
    \r
    In order to target a specific patch version, or to float the version number (2.0-*), the RuntimeFrameworkVersion\r
    property can be used.\r
    \r
    The framework version that is written to the runtimeconfig.json file is based on the actual resolved package version\r
    of Microsoft.NETCore.App.  This is to allow floating the verion number.\r
    \r
    If RuntimeFrameworkVersion is not specified, the following logic applies:\r
    \r
    - When targeting .NET Core 2.0 or higher, Framework-dependent apps use the target framework version with a ".0" patch version\r
    - When targeting .NET Core 2.0 or higher, Self-contained apps use the latest patch version (from when the SDK shipped) for\r
      the specified major.minor version of .NET Core\r
    - When targeting .NET Core 1.x, the latest patch version (from when the SDK shipped) is used for both Framework-dependent and\r
      Self-contained apps.  This is to preserve the same behavior between 1.x and 2.0 SDKs.  If we ship further patch versions\r
      after 1.0.5 and 1.1.2, we may choose to apply the Framework-dependent / Self-contained split to 1.x for those versions.  \r
  -->\r
\r
  <!-- These properties are mainly here as a test hook, as at the time we're implementing the logic which will choose\r
       different versions depending on whether an app is self-contained or not, there aren't any patch versions of\r
       .NET Core 2.0.  So these properties allow us to apply the new behavior to .NET Core 1.x by overriding them.\r
       \r
       Once there is a patch version of .NET Core, we may want to remove these properties and just put the version\r
       numbers directly inside the <Choose> element below. -->\r
  <PropertyGroup Condition="'$(TargetFrameworkIdentifier)' == '.NETCoreApp' And '$(RuntimeFrameworkVersion)' == ''"> \r
    <ImplicitRuntimeFrameworkVersionForFrameworkDependentNetCoreApp1_0\r
      Condition="'$(ImplicitRuntimeFrameworkVersionForFrameworkDependentNetCoreApp1_0)' == ''">1.0.5</ImplicitRuntimeFrameworkVersionForFrameworkDependentNetCoreApp1_0>\r
    <ImplicitRuntimeFrameworkVersionForSelfContainedNetCoreApp1_0\r
      Condition="'$(ImplicitRuntimeFrameworkVersionForSelfContainedNetCoreApp1_0)' == ''">1.0.5</ImplicitRuntimeFrameworkVersionForSelfContainedNetCoreApp1_0>\r
    <ImplicitRuntimeFrameworkVersionForFrameworkDependentNetCoreApp1_1\r
      Condition="'$(ImplicitRuntimeFrameworkVersionForFrameworkDependentNetCoreApp1_1)' == ''">1.1.2</ImplicitRuntimeFrameworkVersionForFrameworkDependentNetCoreApp1_1>\r
    <ImplicitRuntimeFrameworkVersionForSelfContainedNetCoreApp1_1\r
      Condition="'$(ImplicitRuntimeFrameworkVersionForSelfContainedNetCoreApp1_1)' == ''">1.1.2</ImplicitRuntimeFrameworkVersionForSelfContainedNetCoreApp1_1>    \r
  </PropertyGroup>\r
\r
  <!-- Select implicit runtime framework versions -->\r
  <Choose>\r
    <!-- If not targeting .NET Core, or if RuntimeFrameworkVersion is already set, do nothing -->\r
    <When Condition="'$(TargetFrameworkIdentifier)' != '.NETCoreApp' Or '$(RuntimeFrameworkVersion)' != ''" />\r
\r
    <When Condition="'$(_TargetFrameworkVersionWithoutV)' == '1.0'">\r
      <PropertyGroup>\r
        <ImplicitRuntimeFrameworkVersionForFrameworkDependentApp>$(ImplicitRuntimeFrameworkVersionForFrameworkDependentNetCoreApp1_0)</ImplicitRuntimeFrameworkVersionForFrameworkDependentApp>\r
        <ImplicitRuntimeFrameworkVersionForSelfContainedApp>$(ImplicitRuntimeFrameworkVersionForSelfContainedNetCoreApp1_0)</ImplicitRuntimeFrameworkVersionForSelfContainedApp>\r
      </PropertyGroup>\r
    </When>\r
    <When Condition="'$(_TargetFrameworkVersionWithoutV)' == '1.1'">\r
      <PropertyGroup>\r
        <ImplicitRuntimeFrameworkVersionForFrameworkDependentApp>$(ImplicitRuntimeFrameworkVersionForFrameworkDependentNetCoreApp1_1)</ImplicitRuntimeFrameworkVersionForFrameworkDependentApp>\r
        <ImplicitRuntimeFrameworkVersionForSelfContainedApp>$(ImplicitRuntimeFrameworkVersionForSelfContainedNetCoreApp1_1)</ImplicitRuntimeFrameworkVersionForSelfContainedApp>\r
      </PropertyGroup>\r
    </When>\r
\r
    <!-- If targeting the same release that is bundled with the .NET Core SDK, use the bundled package version provided by Microsoft.NETCoreSdk.BundledVersions.props -->\r
    <When Condition="'$(_TargetFrameworkVersionWithoutV)' == '$(BundledNETCoreAppTargetFrameworkVersion)'">\r
      <PropertyGroup>\r
        <ImplicitRuntimeFrameworkVersionForFrameworkDependentApp>$(BundledNETCoreAppPackageVersion)</ImplicitRuntimeFrameworkVersionForFrameworkDependentApp>\r
        <ImplicitRuntimeFrameworkVersionForSelfContainedApp>$(BundledNETCoreAppPackageVersion)</ImplicitRuntimeFrameworkVersionForSelfContainedApp>\r
      </PropertyGroup>\r
    </When>\r
    \r
    <!-- If not covered by the previous cases, use the target framework version for the implicit RuntimeFrameworkVersions -->\r
    <Otherwise>\r
      <PropertyGroup>\r
        <ImplicitRuntimeFrameworkVersionForFrameworkDependentApp>$(_TargetFrameworkVersionWithoutV)</ImplicitRuntimeFrameworkVersionForFrameworkDependentApp>\r
        <ImplicitRuntimeFrameworkVersionForSelfContainedApp>$(_TargetFrameworkVersionWithoutV)</ImplicitRuntimeFrameworkVersionForSelfContainedApp>\r
      </PropertyGroup>\r
    </Otherwise>\r
  </Choose>\r
\r
  <PropertyGroup Condition="'$(TargetFrameworkIdentifier)' == '.NETCoreApp' And '$(RuntimeFrameworkVersion)' == ''">\r
    <RuntimeFrameworkVersion Condition="'$(SelfContained)' == 'true' ">$(ImplicitRuntimeFrameworkVersionForSelfContainedApp)</RuntimeFrameworkVersion>\r
    <RuntimeFrameworkVersion Condition="'$(SelfContained)' != 'true' ">$(ImplicitRuntimeFrameworkVersionForFrameworkDependentApp)</RuntimeFrameworkVersion>\r
  </PropertyGroup>\r
  \r
  <!--\r
    Automatically add Link metadata to items of specific types if they are outside of the project folder and don't already have the Link metadata set.\r
    This will cause them to be shown in the Solution Explorer.  If an item has LinkBase metadata, the automatic Link will start with that value, and\r
    the items will appear in the Solution Explorer under the folder specified by LinkBase.\r
    -->\r
  <ItemGroup Condition="'$(SetLinkMetadataAutomatically)' != 'false'">\r
    <Compile Update="@(Compile)">\r
      <!-- First, add a trailing slash to the LinkBase metadata if necessary.  This allows us to use the same value\r
           for the Link metadata whether or not LinkBase metadata is set: %(LinkBase)%(RecursiveDir)%(Filename)%(Extension) \r
           \r
           Note that RecursiveDir already includes the trailing slash.\r
      -->\r
      <LinkBase Condition="'%(LinkBase)' != ''">$([MSBuild]::EnsureTrailingSlash(%(LinkBase)))</LinkBase>\r
    \r
      <!-- Set the Link metadata if it's not already set and the item is outside of the project directory.\r
           Check whether an item is inside the project directory by seeing if the FullPath starts with EnuserTrailingSlash(MSBuildProjectDirectory)\r
           The FullPath and the MSBuildProjectDirectory will both already be normalized full paths.\r
           The call to [MSBuild]::ValueOrDefault() is there in order to allow calling StartsWith on the FullPath value, since it's\r
           not possible to call a string method on a metadata item directly.  The intrinsic ValueOrDefault() will be more\r
           performant than calling String.Copy(), which has been used for this in other contexts, but actually makes a copy\r
           of the string data.\r
      -->    \r
      <Link Condition="'%(Link)' == '' And !$([MSBuild]::ValueOrDefault('%(FullPath)', '').StartsWith($([MSBuild]::EnsureTrailingSlash($(MSBuildProjectDirectory)))))">%(LinkBase)%(RecursiveDir)%(Filename)%(Extension)</Link>\r
    </Compile>\r
\r
    <AdditionalFiles Update="@(AdditionalFiles)">\r
      <LinkBase Condition="'%(LinkBase)' != ''">$([MSBuild]::EnsureTrailingSlash(%(LinkBase)))</LinkBase>\r
      <Link Condition="'%(Link)' == '' And !$([MSBuild]::ValueOrDefault('%(FullPath)', '').StartsWith($([MSBuild]::EnsureTrailingSlash($(MSBuildProjectDirectory)))))">%(LinkBase)%(RecursiveDir)%(Filename)%(Extension)</Link>\r
    </AdditionalFiles>\r
    \r
    <None Update="@(None)">\r
      <LinkBase Condition="'%(LinkBase)' != ''">$([MSBuild]::EnsureTrailingSlash(%(LinkBase)))</LinkBase>\r
      <Link Condition="'%(Link)' == '' And !$([MSBuild]::ValueOrDefault('%(FullPath)', '').StartsWith($([MSBuild]::EnsureTrailingSlash($(MSBuildProjectDirectory)))))">%(LinkBase)%(RecursiveDir)%(Filename)%(Extension)</Link>\r
    </None>\r
\r
    <Content Update="@(Content)">\r
      <LinkBase Condition="'%(LinkBase)' != ''">$([MSBuild]::EnsureTrailingSlash(%(LinkBase)))</LinkBase>\r
      <Link Condition="'%(Link)' == '' And !$([MSBuild]::ValueOrDefault('%(FullPath)', '').StartsWith($([MSBuild]::EnsureTrailingSlash($(MSBuildProjectDirectory)))))">%(LinkBase)%(RecursiveDir)%(Filename)%(Extension)</Link>\r
    </Content>\r
\r
    <EmbeddedResource Update="@(EmbeddedResource)">\r
      <LinkBase Condition="'%(LinkBase)' != ''">$([MSBuild]::EnsureTrailingSlash(%(LinkBase)))</LinkBase>\r
      <Link Condition="'%(Link)' == '' And !$([MSBuild]::ValueOrDefault('%(FullPath)', '').StartsWith($([MSBuild]::EnsureTrailingSlash($(MSBuildProjectDirectory)))))">%(LinkBase)%(RecursiveDir)%(Filename)%(Extension)</Link>\r
    </EmbeddedResource>\r
  </ItemGroup>\r
\r
  <UsingTask TaskName="CheckForImplicitPackageReferenceOverrides" AssemblyFile="$(MicrosoftNETBuildTasksAssembly)" />\r
\r
  <!-- Remove package references with metadata IsImplicitlyDefined = true, if there are other PackageReference items with the same identity -->\r
  <Target Name="CheckForImplicitPackageReferenceOverrides" BeforeTargets="_CheckForInvalidConfigurationAndPlatform;CollectPackageReferences">\r
    <PropertyGroup>\r
      <ImplicitPackageReferenceInformationLink>https://aka.ms/sdkimplicitrefs</ImplicitPackageReferenceInformationLink>\r
    </PropertyGroup>\r
\r
    <CheckForImplicitPackageReferenceOverrides\r
        PackageReferenceItems="@(PackageReference)"\r
        MoreInformationLink="$(ImplicitPackageReferenceInformationLink)">\r
      <Output TaskParameter="ItemsToRemove" ItemName="_PackageReferenceToRemove" />\r
    </CheckForImplicitPackageReferenceOverrides>\r
\r
    <ItemGroup>\r
      <!-- Note that the condition here is important, otherwise the Remove will operate based just on item identity and remove all items\r
           that had duplicates, instead of leaving the ones without IsImplicitlyDefined set to true. -->\r
      <PackageReference Remove="@(_PackageReferenceToRemove)" Condition="'%(PackageReference.IsImplicitlyDefined)' == 'true' "/>\r
    </ItemGroup>\r
\r
  </Target>\r
\r
  <!-- Running an SDK task before the NuGet restore task causes issues when running on .NET Framework because it causes the\r
      .NET Standard NuGet DLLs to be loaded from the SDK path rather than the .NET Framework versions from the NuGet targets\r
      path.  To avoid this, we create a separate target to run before NuGet restore which deduplicates the items without\r
      causing the SDK tasks to be loaded (but doesn't generate a warning message, because we need to load the tasks for that). -->\r
  <PropertyGroup Condition="'$(DisableImplicitFrameworkReferences)' != 'true'">\r
    <_ImplicitPackageName Condition="'$(TargetFrameworkIdentifier)' == '.NETStandard'">NETStandard.Library</_ImplicitPackageName>\r
    <_ImplicitPackageName Condition="'$(TargetFrameworkIdentifier)' == '.NETCoreApp'">Microsoft.NETCore.App</_ImplicitPackageName>\r
  </PropertyGroup>\r
\r
  <ItemGroup Condition="'$(_ImplicitPackageName)' != ''">\r
    <!-- Filter PackageReference to items where the ItemSpec matches the implicit package name, and add IsImplicitlyDefined metadata\r
         for items that don't have it-->\r
    <_ImplicitPackageReferenceCheck\r
        Include="@(PackageReference->WithMetadataValue('Identity', '$(_ImplicitPackageName)'))">\r
      <IsImplicitlyDefined Condition="'%(IsImplicitlyDefined)' != 'true' ">false</IsImplicitlyDefined>\r
    </_ImplicitPackageReferenceCheck>\r
\r
    <!-- Now filter down to an item with just the implicit reference and another one with just the overriding reference -->\r
    <_ImplicitPackageReference Include="@(_ImplicitPackageReferenceCheck->WithMetadataValue('IsImplicitlyDefined', 'true'))"/>\r
    <_OverridingPackageReference Include="@(_ImplicitPackageReferenceCheck->WithMetadataValue('IsImplicitlyDefined', 'false'))"/>\r
  </ItemGroup>\r
\r
  <Target Name="CheckForImplicitPackageReferenceOverridesBeforeRestore" BeforeTargets="_GetRestoreProjectStyle">\r
    <ItemGroup>\r
      <!-- Remove both the implicit and the override item, if there was both an implicit and an override item -->\r
      <PackageReference Remove="@(PackageReference->WithMetadataValue('Identity', '$(_ImplicitPackageName)'))"\r
                        Condition="'@(_ImplicitPackageReference)' != '' And '@(_OverridingPackageReference)' != ''"\r
                      />\r
\r
      <!-- Add the override item back -->\r
      <PackageReference Include="@(_OverridingPackageReference)"\r
                        Condition="'@(_ImplicitPackageReference)' != '' And '@(_OverridingPackageReference)' != ''" />\r
    </ItemGroup>\r
  </Target>\r
\r
  <UsingTask TaskName="CheckForDuplicateItems" AssemblyFile="$(MicrosoftNETBuildTasksAssembly)" />\r
\r
  <Target Name="CheckForDuplicateItems" BeforeTargets="_CheckForInvalidConfigurationAndPlatform;CoreCompile">\r
\r
    <PropertyGroup>\r
      <DefaultItemsMoreInformationLink>https://aka.ms/sdkimplicititems</DefaultItemsMoreInformationLink>\r
\r
      <!-- For the design-time build, we will continue on error and remove the duplicate items.\r
           This is because otherwise there won't be any references to pass to the compiler, leading to design-time\r
           compilation errors for every API that is used in the project.  Amidst all the compile errors, it would\r
           be easy to miss the duplicate items error which is the real source of the problem. -->\r
      <CheckForDuplicateItemsContinueOnError>false</CheckForDuplicateItemsContinueOnError>\r
      <CheckForDuplicateItemsContinueOnError Condition="'$(DesignTimeBuild)' == 'true'">ErrorAndContinue</CheckForDuplicateItemsContinueOnError>\r
    </PropertyGroup>\r
\r
    <CheckForDuplicateItems\r
      Items="@(Compile)"\r
      ItemName="Compile"\r
      DefaultItemsEnabled="$(EnableDefaultItems)"\r
      DefaultItemsOfThisTypeEnabled="$(EnableDefaultCompileItems)"\r
      PropertyNameToDisableDefaultItems="EnableDefaultCompileItems"\r
      MoreInformationLink="$(DefaultItemsMoreInformationLink)"\r
      ContinueOnError="$(CheckForDuplicateItemsContinueOnError)">\r
      <Output TaskParameter="DeduplicatedItems" ItemName="DeduplicatedCompileItems" />\r
    </CheckForDuplicateItems>\r
\r
    <CheckForDuplicateItems\r
      Items="@(EmbeddedResource)"\r
      ItemName="EmbeddedResource"\r
      DefaultItemsEnabled="$(EnableDefaultItems)"\r
      DefaultItemsOfThisTypeEnabled="$(EnableDefaultEmbeddedResourceItems)"\r
      PropertyNameToDisableDefaultItems="EnableDefaultEmbeddedResourceItems"\r
      MoreInformationLink="$(DefaultItemsMoreInformationLink)"\r
      ContinueOnError="$(CheckForDuplicateItemsContinueOnError)">\r
      <Output TaskParameter="DeduplicatedItems" ItemName="DeduplicatedEmbeddedResourceItems" />\r
    </CheckForDuplicateItems>\r
    \r
    <!-- Default content items are enabled by the Web SDK, not the .NET SDK, but we check it here for simplicity -->\r
    <CheckForDuplicateItems\r
      Items="@(Content)"\r
      ItemName="Content"\r
      DefaultItemsEnabled="$(EnableDefaultItems)"\r
      DefaultItemsOfThisTypeEnabled="$(EnableDefaultContentItems)"\r
      PropertyNameToDisableDefaultItems="EnableDefaultContentItems"\r
      MoreInformationLink="$(DefaultItemsMoreInformationLink)"\r
      ContinueOnError="$(CheckForDuplicateItemsContinueOnError)">\r
      <Output TaskParameter="DeduplicatedItems" ItemName="DeduplicatedContentItems" />\r
    </CheckForDuplicateItems>\r
\r
    <ItemGroup Condition="'$(DesignTimeBuild)' == 'true' And '@(DeduplicatedCompileItems)' != ''">\r
      <Compile Remove="@(Compile)" />\r
      <Compile Include="@(DeduplicatedCompileItems)" />\r
    </ItemGroup>\r
\r
    <ItemGroup Condition="'$(DesignTimeBuild)' == 'true' And '@(DeduplicatedEmbeddedResourceItems)' != ''">\r
      <EmbeddedResource Remove="@(EmbeddedResource)" />\r
      <EmbeddedResource Include="@(DeduplicatedEmbeddedResourceItems)" />\r
    </ItemGroup>\r
\r
    <ItemGroup Condition="'$(DesignTimeBuild)' == 'true' And '@(DeduplicatedContentItems)' != ''">\r
      <Content Remove="@(Content)" />\r
      <Content Include="@(DeduplicatedContentItems)" />\r
    </ItemGroup>\r
    \r
  </Target>\r
</Project>\r