Settings.targets

<Project DefaultTargets="Build" InitialTargets="RestoreToolsetCheck" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" TreatAsLocalProperty="OutDir;Configuration">

  <PropertyGroup>
    <ProjectDir>$(MSBuildThisFileDirectory)..\..\</ProjectDir>
    <NuGetToolPath Condition="">$(ProjectDir)nuget.exe</NuGetToolPath>
    <ToolsetPackagesDir>$(ProjectDir)build\ToolsetPackages\</ToolsetPackagesDir>
    <ToolsetPackagesSemaphore>$(ToolsetPackagesDir)toolsetpackages.semaphore</ToolsetPackagesSemaphore>
    <NuGetPackageRoot Condition="'$(NuGetPackageRoot)' == ''">$(NUGET_PACKAGES)</NuGetPackageRoot> <!-- Respect environment variable if set -->
    <NuGetPackageRoot Condition="'$(NuGetPackageRoot)' == '' and
                                 '$(OS)' == 'Windows_NT'">$(UserProfile)\.nuget\packages</NuGetPackageRoot>
    <NuGetPackageRoot Condition="'$(NuGetPackageRoot)' == '' and
                                 '$(OS)' != 'Windows_NT'">$(HOME)\.nuget\packages</NuGetPackageRoot>

    <!-- 
        $(OS) is only specific enough for windows builds.  For non-windows builds the identifier
        is specified on the command line of MSBuild
    -->
    <BaseNuGetRuntimeIdentifier Condition="'$(OS)' == 'Windows_NT'">win7</BaseNuGetRuntimeIdentifier>
  </PropertyGroup>

  <!-- Import the global NuGet packages -->
  <PropertyGroup>
    <ToolsetCompilerPackageName>Microsoft.Net.Compilers</ToolsetCompilerPackageName>
    <ToolsetCompilerPackageVersion>1.3.2</ToolsetCompilerPackageVersion>
    <RoslynDiagnosticsNugetPackageVersion>1.2.0-beta2</RoslynDiagnosticsNugetPackageVersion>
    <RoslynDiagnosticsPropsFilePath>$(NuGetPackageRoot)\Microsoft.Net.RoslynDiagnostics\$(RoslynDiagnosticsNugetPackageVersion)\build\Microsoft.Net.RoslynDiagnostics.props</RoslynDiagnosticsPropsFilePath>
    <RoslynBuildUtilFilePath>$(NuGetPackageRoot)\Roslyn.Build.Util\0.9.4-portable\lib\dotnet\Roslyn.MSBuild.Util.dll</RoslynBuildUtilFilePath>
    <AdditionalFileItemNames>$(AdditionalFileItemNames);PublicAPI</AdditionalFileItemNames>
  </PropertyGroup>

  <!-- Workaround until we move to Microsoft.Net.Compilers.nupkg with this fix: https://github.com/dotnet/roslyn/commit/05c12ebfcdd08a02dbceded5327a8da7a7df23be:
       Use the Microsoft.Net.Compilers.props file with the fix checked into the repo instead of the one that comes along with the nuget package: $(NuGetPackageRoot)\Microsoft.Net.Compilers\$(ToolsetCompilerPackageVersion)\build\Microsoft.Net.Compilers.props -->
  <PropertyGroup>
    <ToolsetCompilerPropsFilePath>$(MSBuildThisFileDirectory)Microsoft.Net.Compilers.props</ToolsetCompilerPropsFilePath>
  </PropertyGroup>

  <!-- 
    Roslyn uses the WriteCodeFragment task to output generated assembly attributes.  In MSBuild 14.0 update 1 this task 
    produces non-deterministic output.  This is fixed in update 2 but until that is released we use a hand patched
    version of the Task that is deterministic.  

    MSBuild bug: https://github.com/Microsoft/msbuild/issues/408
    Bug tracking removing this: https://github.com/dotnet/roslyn/issues/8421
  -->
  <UsingTask TaskName="Roslyn.MSBuild.Util.WriteCodeFragmentEx"
             AssemblyFile="$(RoslynBuildUtilFilePath)" />

  <Target Name="RestoreToolsetCheck"
      Condition="'$(BuildingProject)' == 'true'">
      <Error Text="Toolset packages have not been restored, run Restore.cmd before building"
             Condition="!Exists('$(ToolsetCompilerPropsFilePath)')" />
  </Target>

  <!-- Prevent vsix manifests from being copied to the shared output directory, makes build more deterministic -->
  <PropertyGroup>
    <CopyVsixManifestToOutput>false</CopyVsixManifestToOutput>
  </PropertyGroup>

  <!-- Point to the reference assemblies on unix -->
  <PropertyGroup Condition="'$(OS)' != 'Windows_NT'">
      <TargetFrameworkRootPath>$(MSBuildBinPath)\reference-assemblies\Framework</TargetFrameworkRootPath>
  </PropertyGroup>

  <!-- This file is imported by all projects at the beginning of the project files -->
  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props"
          Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props') AND '$(MSBuildProjectExtension)' != '.vcxproj'" />

  <!-- NuGet props aren't imported by default on *nix so we do that here -->
  <Import Project="$(MSBuildExtensionsPath)\Microsoft\NuGet\Microsoft.NuGet.props"
          Condition="'$(OS)' != 'Windows_NT'" />

  <!-- The /publicsign argument is required for the compiler, but the current MSBuild
       build task can't be redirected and even if it could the new build task is not
       built against the xplat MSBuild references so it can't be loaded properly. Providing
       a response file works around the problem by directly adding the public sign argument
       to all unix compilations. This shouldn't present a problem as it's impossible to
       fully sign on unix at the moment anyway. Tracked by #7756. -->
  <PropertyGroup Condition="'$(OS)' != 'Windows_NT'">
      <CompilerResponseFile>$(MSBuildThisFileDirectory)..\unix\extra_unix_args.rsp</CompilerResponseFile>
  </PropertyGroup>

  <PropertyGroup>
    <VisualStudioVersion Condition="'$(VisualStudioVersion)' == ''">14.0</VisualStudioVersion>
  </PropertyGroup>

  <PropertyGroup>
    <VisualStudioReferenceMajorVersion Condition="'$(VisualStudioReferenceMajorVersion)' == ''">$(VisualStudioVersion.Substring(0, $(VisualStudioVersion.IndexOf('.'))))</VisualStudioReferenceMajorVersion>
    <VisualStudioReferenceAssemblyVersion Condition="'$(VisualStudioReferenceAssemblyVersion)' == ''">$(VisualStudioReferenceMajorVersion).0.0.0</VisualStudioReferenceAssemblyVersion>
    <VisualStudioCodename>Dev$(VisualStudioReferenceMajorVersion)</VisualStudioCodename>

    <MinimumVisualStudioVersion>$(VisualStudioVersion)</MinimumVisualStudioVersion>

    <VSLToolsPath Condition="'$(VSLToolsPath)' == ''">$([System.IO.Path]::GetFullPath('$(MSBuildThisFileDirectory)\..'))</VSLToolsPath>
    <VSLTargetsPath Condition="'$(VSLTargetsPath)' == ''">$(MSBuildThisFileDirectory)</VSLTargetsPath>

    <Configuration Condition="'$(Configuration)' == ''">Debug</Configuration>

    <SignAssembly Condition="'$(SignAssembly)' == ''">true</SignAssembly>

    <UseRoslynAnalyzers Condition="'$(UseRoslynAnalyzers)' == ''">true</UseRoslynAnalyzers>

    <Deterministic>True</Deterministic>

    <!-- Only portable PDBs are supported xplat -->
    <DebugType Condition="'$(OS)' != 'Windows_NT'">portable</DebugType>
    <DebugType Condition="'$(OS)' == 'Windows_NT'">pdbonly</DebugType>
  </PropertyGroup>

  <PropertyGroup Condition="'$(VSCOMNTOOLS)' == ''">
    <VSCOMNTOOLS>$([System.Environment]::ExpandEnvironmentVariables("%VS$(VisualStudioReferenceMajorVersion)0COMNTOOLS%"))</VSCOMNTOOLS>
  </PropertyGroup>
  
  <PropertyGroup Condition="'$(DevEnvDir)' == ''">
    <DevEnvDir>$(VSCOMNTOOLS)\..\IDE</DevEnvDir>
    <DevEnvDir>$([System.IO.Path]::GetFullPath('$(DevEnvDir)'))</DevEnvDir>
  </PropertyGroup>
  
  <Choose>
    <When Condition="'$(VisualStudioVersion)' == '12.0'">
      <PropertyGroup>
        <MSBuildAssemblyNameFragment>v12.0</MSBuildAssemblyNameFragment>
      </PropertyGroup>
    </When>

    <Otherwise>
      <PropertyGroup>
        <MSBuildAssemblyNameFragment>Core</MSBuildAssemblyNameFragment>
      </PropertyGroup>
    </Otherwise>
  </Choose>
  
  <!-- This is a really hacky way to detect whether we are on a legacy or a willow based VS install.
       Basically, we check for a registry key that will only exist in legacy VS installs, and assume
       we are a willow based installation if our VSVersion is 15.0 and the registry key doesn't exist. -->
  <PropertyGroup>
    <IsVSBeforeDev15Preview4 Condition="'$(OS)' == 'Windows_NT' AND '$(registry:HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\VisualStudio\15.0@InstallDir)' != ''">true</IsVSBeforeDev15Preview4>
    <IsVSBeforeDev15Preview4 Condition="'$(OS)' == 'Windows_NT' AND '$(registry:HKEY_LOCAL_MACHINE\SOFTWARE\WOW6432Node\Microsoft\VisualStudio\15.0@InstallDir)' != ''">true</IsVSBeforeDev15Preview4>
    <IsVSBeforeDev15Preview4 Condition="'$(IsVSBeforeDev15Preview4)' == 'true' AND Exists('$(MSBuildBinPath)\..\..\..\Common7\IDE\devenv.isolation.ini')">false</IsVSBeforeDev15Preview4>
    <IsVSBeforeDev15Preview4 Condition="'$(IsVSBeforeDev15Preview4)' == 'true' AND Exists('$(MSBuildBinPath)\..\..\..\..\Common7\IDE\devenv.isolation.ini')">false</IsVSBeforeDev15Preview4>
  </PropertyGroup>

  <Choose>
    <When Condition="'$(VisualStudioVersion)' == '15.0'">
      <Choose>
        <When Condition="'$(IsVSBeforeDev15Preview4)' == 'true'">
          <PropertyGroup>
            <VisualStudioBuildToolsNuGetPackagePath>$(NuGetPackageRoot)\Microsoft.VSSDK.BuildTools\15.0.25201-dev15preview2</VisualStudioBuildToolsNuGetPackagePath>
          </PropertyGroup>
        </When>

        <Otherwise>
          <PropertyGroup>
            <VisualStudioBuildToolsNuGetPackagePath>$(NuGetPackageRoot)\Microsoft.VSSDK.BuildTools\15.0.25604-Preview4</VisualStudioBuildToolsNuGetPackagePath>
          </PropertyGroup>
        </Otherwise>
      </Choose>
    </When>

    <Otherwise>
      <PropertyGroup>
        <VisualStudioBuildToolsNuGetPackagePath>$(NuGetPackageRoot)\Microsoft.VSSDK.BuildTools\14.3.25420</VisualStudioBuildToolsNuGetPackagePath>
      </PropertyGroup>
    </Otherwise>
  </Choose>

  <Import Project="$(VisualStudioBuildToolsNuGetPackagePath)\build\Microsoft.VsSDK.BuildTools.props" Condition="'$(OS)' == 'Windows_NT'" />

  <!-- Build reliability -->
  <PropertyGroup>
    <OverwriteReadOnlyFiles Condition="'$(OverwriteReadOnlyFiles)' == ''">true</OverwriteReadOnlyFiles>
  </PropertyGroup>

  <!-- Project language -->
  <PropertyGroup Condition="'$(ProjectLanguage)' == ''">
    <ProjectLanguage Condition="'$(MSBuildProjectExtension)' == '.csproj' OR '$(Language)' == 'C#'">CSharp</ProjectLanguage>
    <ProjectLanguage Condition="'$(MSBuildProjectExtension)' == '.vbproj' OR '$(Language)' == 'VB'">VB</ProjectLanguage>
    <ProjectLanguage Condition="'$(MSBuildProjectExtension)' == '.vcxproj' OR '$(Language)' == 'C++'">C++</ProjectLanguage>
  </PropertyGroup>

  <PropertyGroup Condition="'$(OS)' == 'Windows_NT'">
    <!-- Use the compiler server -->
    <UseSharedCompilation>true</UseSharedCompilation>
  </PropertyGroup>

  <!-- Import the props files from the toolset NuGet packages if we're not in a bootstrap build -->
  <ImportGroup Label="GlobalNuGets" Condition="'$(BootstrapBuildPath)' == ''">
    <Import Project="$(ToolsetCompilerPropsFilePath)"
            Condition="Exists('$(ToolsetCompilerPropsFilePath)') And '$(OS)' == 'Windows_NT'" />
  </ImportGroup>

  <ImportGroup>
    <Import Project="$(RoslynDiagnosticsPropsFilePath)"
            Condition="Exists('$(RoslynDiagnosticsPropsFilePath)') And ('$(UseRoslynAnalyzers)' == 'true')" />
  </ImportGroup>

  <!-- Otherwise, use the task from the bootstrap location. This is necessary
       to support new properties on the build task. -->
  <UsingTask TaskName="Microsoft.CodeAnalysis.BuildTasks.Csc"
             AssemblyFile="$(BootstrapBuildPath)\Microsoft.Build.Tasks.CodeAnalysis.dll"
             Condition="'$(BootstrapBuildPath)' != ''" />
  <UsingTask TaskName="Microsoft.CodeAnalysis.BuildTasks.Vbc"
             AssemblyFile="$(BootstrapBuildPath)\Microsoft.Build.Tasks.CodeAnalysis.dll"
             Condition="'$(BootstrapBuildPath)' != ''" />

  <PropertyGroup Condition="'$(BootstrapBuildPath)' != ''">
    <UseSharedCompilation>true</UseSharedCompilation>
    <CSharpCoreTargetsPath>$(BootstrapBuildPath)\Microsoft.CSharp.Core.targets</CSharpCoreTargetsPath>
    <VisualBasicCoreTargetsPath>$(BootstrapBuildPath)\Microsoft.VisualBasic.Core.targets</VisualBasicCoreTargetsPath>
  </PropertyGroup>


  <!-- Common project settings -->
  <PropertyGroup>
    <DeployToSamplesSubfolder Condition="'$(DeployToSamplesSubfolder)' == ''">false</DeployToSamplesSubfolder>
    <FileAlignment>512</FileAlignment>
    <HighEntropyVA>true</HighEntropyVA>
    <Features>strict</Features>
  </PropertyGroup>

  <!--
    If TargetNetFX20 is true the project targets Framework 2.0 reference assemblies provided by Microsoft.NetFX20 nuget package.
    Use the latest Framework toolset to build, but set msbuild properties below
    so to avoid 4.5 specific artifacts to be added to the compilation (references, attributes).
  -->
  <PropertyGroup Condition="'$(TargetNetFX20)' == 'true'">
    <GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
    <AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
    <NoStdLib>true</NoStdLib>
    <FrameworkPathOverride>$(NuGetPackageRoot)\Microsoft.NetFX20\1.0.3\lib\net20</FrameworkPathOverride>
    <NuGetTargetMoniker>.NETFramework,Version=v2.0</NuGetTargetMoniker>
  </PropertyGroup>

  <ItemGroup Condition="'$(ProjectLanguage)' == 'CSharp' AND '$(TargetNetFX20)' == 'true'">
    <_ExplicitReference Include="$(FrameworkPathOverride)\mscorlib.dll" />
  </ItemGroup>

  <PropertyGroup>
    <OutDir Condition="'$(OutDir)' == ''">$([System.IO.Path]::GetFullPath('$(MSBuildThisFileDirectory)\..\..\Binaries\$(Configuration)'))\</OutDir>
    <BaseIntermediateOutputPath Condition="'$(BaseIntermediateOutputPath)' == ''">$([System.IO.Path]::GetFullPath('$(MSBuildThisFileDirectory)\..\..\Binaries\Obj\$(MSBuildProjectName)'))\</BaseIntermediateOutputPath>
  </PropertyGroup>

  <PropertyGroup>
    <!-- Capture the root, so we'll always have it even if we're building to a sub-folder -->
    <VSLOutDir>$(OutDir)</VSLOutDir>
  </PropertyGroup>

  <PropertyGroup>
      <CompilerGeneratorToolsDir>$(OutDir)CompilerGeneratorTools\</CompilerGeneratorToolsDir>
  </PropertyGroup>

  <PropertyGroup Condition="'$(DeployToSamplesSubfolder)' == 'true'">
    <OutDir>$(OutDir)\Samples\$(MSBuildProjectName)</OutDir>
  </PropertyGroup>

  <PropertyGroup>
  <!-- Disable AppX packaging for the Roslyn source. Not setting this to false has the side effect
       that any builds of portable projects end up in a sub folder of $(OutDir). Search for this flag in
       Microsoft.Common.CurrentVersion.targets to see how it is consumed -->
    <WindowsAppContainer>false</WindowsAppContainer>
  </PropertyGroup>

  <Choose>
    <!-- VB specific settings -->
    <When Condition="'$(ProjectLanguage)' == 'VB'">
      <PropertyGroup>
        <MyType>Empty</MyType>
        <OptionCompare>Binary</OptionCompare>
        <OptionExplicit>On</OptionExplicit>
        <OptionInfer>On</OptionInfer>
        <OptionStrict>On</OptionStrict>
        <RootNamespace></RootNamespace>
        <VBRuntime>Embed</VBRuntime>
      </PropertyGroup>
      <ItemGroup>
        <Import Include="Microsoft.VisualBasic" />
        <Import Include="System" />
        <Import Include="System.Collections" />
        <Import Include="System.Collections.Generic" />
        <Import Include="System.Diagnostics" />
      </ItemGroup>
      <ItemGroup Condition="'$(TargetNetFX20)' != 'true'">
        <Import Include="System.Linq" />
      </ItemGroup>
      <PropertyGroup Condition="'$(Configuration)' == 'Debug'">
        <DebugSymbols>true</DebugSymbols>
        <DefineDebug>true</DefineDebug>
        <DefineTrace>true</DefineTrace>
      </PropertyGroup>
      <PropertyGroup Condition="'$(Configuration)' == 'Release'">
        <DefineTrace>true</DefineTrace>
        <Optimize>true</Optimize>
      </PropertyGroup>
    </When>

    <!-- C# specific settings -->
    <When Condition="'$(ProjectLanguage)' == 'CSharp'">
      <PropertyGroup>
        <WarningLevel>4</WarningLevel>
        <ErrorReport>prompt</ErrorReport>

        <!-- Suppress the following warnings by default for C# projects
                1591: So far we've chosen to implicitly implement interfaces and as a consequence
                      the methods are public.  We don't want to duplicate documentation for them
                      and hence suppress this warning until we get closer to release and a more
                      thorough documentation story
        -->
        <NoWarn>$(NoWarn);1591</NoWarn>
      </PropertyGroup>
      <PropertyGroup Condition="'$(Configuration)' == 'Debug'">
        <DebugSymbols>true</DebugSymbols>
        <DefineConstants>DEBUG;TRACE</DefineConstants>
      </PropertyGroup>
      <PropertyGroup Condition="'$(Configuration)' == 'Release'">
        <DefineConstants>TRACE</DefineConstants>
        <Optimize>true</Optimize>
      </PropertyGroup>
    </When>

    <!-- C++ specific settings -->
    <When Condition="'$(ProjectLanguage)' == 'C++'">
      <PropertyGroup>
        <!-- Put intermediate outputs in the same place as managed projects for sanity -->
        <IntDir>$(ProjectDir)obj\$(Configuration)\</IntDir>

        <!-- We just always want to build with whatever toolset matches the VS you're building with -->
        <PlatformToolset>v$(VisualStudioReferenceMajorVersion)0</PlatformToolset>
      </PropertyGroup>
    </When>
  </Choose>

  <PropertyGroup>
    <CopyVSReferencesToOutput>True</CopyVSReferencesToOutput>
  </PropertyGroup>

  <!-- 
    When running our determinism tests we need to copy the diagnostic file from the intermediate directory 
    to the location of the binary.  This ensures .dll and .dll.key are next to each other to be picked up
    by our test scripts
  -->
  <Target Name="CopyDeterministicBuildDiagnosticFile" Condition="'$(DebugDeterminism)' != ''" AfterTargets="CoreCompile">
    <Copy
        Condition="Exists(@(IntermediateAssembly -> '%(fullpath).key'))"
        SourceFiles="@(IntermediateAssembly -> '%(fullpath).key')"
        DestinationFolder="$(OutDir)" />
  </Target>
 </Project>