Settings.props

<?xml version="1.0" encoding="utf-8"?>
<!-- Copyright (c)  Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information. -->
<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">

  <PropertyGroup>
    <RepoRoot>$([System.IO.Path]::GetFullPath('$(MSBuildThisFileDirectory)..\..\'))</RepoRoot>
    <RepositoryUrl>https://github.com/dotnet/roslyn</RepositoryUrl>
    <RepositoryRawUrl>https://raw.githubusercontent.com/dotnet/roslyn</RepositoryRawUrl>
  </PropertyGroup>

  <Import Project="Packages.props" />
  <Import Project="FixedPackages.props" />
  <Import Project="Tools.props" />
  <Import Project="Versions.props" />

  <PropertyGroup>
    <Company>Microsoft Corporation</Company>
    <Copyright>© Microsoft Corporation. All rights reserved.</Copyright>
    <Authors>Microsoft</Authors>

    <JenkinsBuild>false</JenkinsBuild>
    <JenkinsBuild Condition="'$(JENKINS_HOME)' != ''">true</JenkinsBuild>
    <DeveloperBuild>false</DeveloperBuild>
    <DeveloperBuild Condition="'$(OfficialBuild)' != 'true' AND '$(JenkinsBuild)' != 'true'">true</DeveloperBuild>

    <NuGetToolPath>$(RepoRoot)nuget.exe</NuGetToolPath>
    <!-- Disable the implicit nuget fallback folder as it makes it hard to locate and copy ref assemblies to the test output folder -->
    <DisableImplicitNuGetFallbackFolder>true</DisableImplicitNuGetFallbackFolder>
    <ToolsetPackagesDir>$(RepoRoot)build\ToolsetPackages\</ToolsetPackagesDir>
    <VSIXExpInstallerPackageName>RoslynTools.Microsoft.VSIXExpInstaller</VSIXExpInstallerPackageName>
    <VSIXExpInstallerPackageVersion>0.2.1-beta</VSIXExpInstallerPackageVersion>
    <RoslynDiagnosticsNugetPackageVersion>$(MicrosoftNetRoslynDiagnosticsVersion)</RoslynDiagnosticsNugetPackageVersion>
    <!-- Disable analyzers if NuGet deviated from the expected restore location (e.g. by changing case on a case-sensitive file system) -->
    <UseRoslynAnalyzers Condition="!Exists('$(NuGetPackageRoot)\Microsoft.CodeQuality.Analyzers\$(RoslynDiagnosticsNugetPackageVersion)\analyzers\dotnet\cs\Microsoft.CodeQuality.Analyzers.dll')">False</UseRoslynAnalyzers>
    <RoslynDiagnosticsPropsFilePath>$(NuGetPackageRoot)/microsoft.net.roslyndiagnostics/$(RoslynDiagnosticsNugetPackageVersion)/build/Microsoft.Net.RoslynDiagnostics.props</RoslynDiagnosticsPropsFilePath>
    <RoslynPortableTargetFrameworks>net461;netcoreapp2.0</RoslynPortableTargetFrameworks>
    <RoslynPortableTargetFrameworks46>net46;netcoreapp2.0</RoslynPortableTargetFrameworks46>
    <RoslynPortableRuntimeIdentifiers>win;win-x64;linux-x64;osx-x64</RoslynPortableRuntimeIdentifiers>
    <RoslynDesktopRuntimeIdentifier>win</RoslynDesktopRuntimeIdentifier>
    <RoslynDesktopRuntimeIdentifierX86>win-x86</RoslynDesktopRuntimeIdentifierX86>
    <UseSharedCompilation>true</UseSharedCompilation>

    <UsingToolPdbConverter>true</UsingToolPdbConverter>
    <Features>strict, IOperation</Features>
    <ProduceReferenceAssembly>true</ProduceReferenceAssembly>
    <Configuration Condition="'$(Configuration)' == ''">Debug</Configuration>
    <SignAssembly>true</SignAssembly>
    <GenerateDocumentationFile>true</GenerateDocumentationFile>
    <!-- The new SDK introduced a GenerateAssemblyInfo target, which is disabled by GenerateAssemblyInfo=false.
         Otherwise, it writes to the same file (GeneratedAssemblyInfoFile) as our GenerateAssemblyInfoFile target.
         Follow-up issue to reconcile the two: https://github.com/dotnet/roslyn/issues/19645 -->
    <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
    <UseRoslynAnalyzers Condition="'$(UseRoslynAnalyzers)' == ''">true</UseRoslynAnalyzers>
    <BaseOutputPath Condition="'$(BaseOutputPath)' == ''">$(RepoRoot)Binaries\</BaseOutputPath>
    <OutputPath>$(BaseOutputPath)$(Configuration)\</OutputPath>
    <BaseIntermediateOutputPath Condition="'$(BaseIntermediateOutputPath)' == ''">$(RepoRoot)Binaries\Obj\</BaseIntermediateOutputPath>
    <BaseIntermediateOutputPath>$(BaseIntermediateOutputPath)$(MSBuildProjectName)\</BaseIntermediateOutputPath>
    <IntermediateOutputPath>$(BaseIntermediateOutputPath)$(Configuration)</IntermediateOutputPath>
    <ArtifactsSymStoreDirectory Condition="'$(DeveloperBuild)' != 'true' and '$(OS)' == 'Windows_NT'">$(BaseOutputPath)$(Configuration)\SymStore\</ArtifactsSymStoreDirectory>

    <MicrosoftCSharpRefPath>$(NuGetPackageRoot)/microsoft.csharp/$(MicrosoftCSharpVersion)/ref/netstandard1.0/</MicrosoftCSharpRefPath>

    <ToolsetPackagesSemaphore>$(ToolsetPackagesDir)toolsetpackages.semaphore</ToolsetPackagesSemaphore>
    <ToolsetCompilerPackageName Condition="'$(MSBuildRuntimeType)' != 'Core'">Microsoft.Net.Compilers</ToolsetCompilerPackageName>
    <ToolsetCompilerPackageName Condition="'$(MSBuildRuntimeType)' == 'Core'">Microsoft.NETCore.Compilers</ToolsetCompilerPackageName>
    <ToolsetCompilerPackageVersion Condition="'$(MSBuildRuntimeType)' != 'Core'">$(MicrosoftNetCompilersVersion)</ToolsetCompilerPackageVersion>
    <ToolsetCompilerPackageVersion Condition="'$(MSBuildRuntimeType)' == 'Core'">$(MicrosoftNETCoreCompilersVersion)</ToolsetCompilerPackageVersion>
    <ToolsetCompilerPropsFilePath>$(NuGetPackageRoot)/$(ToolsetCompilerPackageName.ToLower())/$(ToolsetCompilerPackageVersion)/build/$(ToolsetCompilerPackageName).props</ToolsetCompilerPropsFilePath>
    <TargetFrameworkRootPath>$(NuGetPackageRoot)\roslyntools.referenceassemblies\$(RoslynToolsReferenceAssembliesVersion)\tools\framework</TargetFrameworkRootPath>

    <VisualStudioVersion Condition="'$(VisualStudioVersion)' == ''">15.0</VisualStudioVersion>
    <VisualStudioReferenceMajorVersion Condition="'$(VisualStudioReferenceMajorVersion)' == ''">$(VisualStudioVersion.Substring($([System.Convert]::ToInt32(0)), $(VisualStudioVersion.IndexOf('.'))))</VisualStudioReferenceMajorVersion>
    <VisualStudioReferenceAssemblyVersion Condition="'$(VisualStudioReferenceAssemblyVersion)' == ''">$(VisualStudioReferenceMajorVersion).0.0.0</VisualStudioReferenceAssemblyVersion>
    <VisualStudioCodename>Dev$(VisualStudioReferenceMajorVersion)</VisualStudioCodename>
    <MinimumVisualStudioVersion>$(VisualStudioVersion)</MinimumVisualStudioVersion>

    <!-- 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 $(OutputPath). Search for this flag in
         Microsoft.Common.CurrentVersion.targets to see how it is consumed -->
    <WindowsAppContainer>false</WindowsAppContainer>

    <MSBuildAssemblyNameFragment>Core</MSBuildAssemblyNameFragment>

    <!-- To copy .dll.config and .exe.config files of the referenced projects to the output dir
         (see https://github.com/Microsoft/msbuild/issues/1307) -->
    <AllowedReferenceRelatedFileExtensions>$(AllowedReferenceRelatedFileExtensions);.dll.config;.exe.config</AllowedReferenceRelatedFileExtensions>

    <!-- This controls the places MSBuild will consult to resolve assembly references.  This is 
         kept as minimal as possible to make our build reliable from machine to machine.  Global
         locations such as GAC, AssemblyFoldersEx, etc ... are deliberately removed from this 
         list as they will not be the same from machine to machine -->
    <AssemblySearchPaths>
      {TargetFrameworkDirectory};
      {RawFileName};
    </AssemblySearchPaths>

    <!-- https://github.com/dotnet/roslyn/issues/21183 -->
    <ImplicitlyExpandNETStandardFacades>false</ImplicitlyExpandNETStandardFacades>

    <RestoreProjectStyle>PackageReference</RestoreProjectStyle>

    <!-- Live Unit Testing does not currently support PackageReference style restore unless the Sdk="Microsoft.NET.Sdk" attribute is used on projects.
         Removal of this work-around tracked by:  https://github.com/dotnet/roslyn/issues/20427 -->
    <ProjectAssetsFile Condition="'$(BuildingForLiveUnitTesting)' == 'true'">$(LiveUnitTestingOriginalBaseIntermediateOutputPath)project.assets.json</ProjectAssetsFile>

    <!-- https://github.com/dotnet/roslyn/issues/21272 -->
    <GenerateResourceMSBuildRuntime Condition="'$(TargetFramework)' == 'netcoreapp2.0'">CurrentRuntime</GenerateResourceMSBuildRuntime>

    <!--
      Official build:
       - Build standalone Portable PDBs to reduce the size of the binaries.
       - Convert Portable PDBs to Windows PDBs and publish the converted PDBs to Symbol Store to allow WinDBG, 
         Watson and other tools to find symbol format they understand.

      Jenkins build:
       - Embed PDBs to make it easier to debug Jenkins crash dumps.

      Developer build:
       - Embed PDBs to be consistent with Jenkins builds.
    -->
    <RoslynDebugType Condition="'$(OfficialBuild)' == 'true'">portable</RoslynDebugType>
    <RoslynDebugType Condition="'$(OfficialBuild)' != 'true'">embedded</RoslynDebugType>

    <!-- 
      The source root path used for deterministic normalization of source paths.
      
      If set the value is used in PathMap to instruct the compiler to normalize source paths 
      emitted to the binary and PDB and as a root for Source Link mapping.
      If set must end with a directory separator.
      
      If unset the PathMap need to be set explicitly to facilitate full determinism.
      
      The path can't be just a single '/' due to bug in Roslyn compilers:
      https://github.com/dotnet/roslyn/issues/22815
    -->
    <DeterministicSourceRoot Condition="'$(DeveloperBuild)' != 'true'">/_/</DeterministicSourceRoot>

    <EnableSourceLink Condition="'$(DeveloperBuild)' != 'true'">true</EnableSourceLink>
    <EnableDefaultNoneItems>false</EnableDefaultNoneItems>

    <!-- 
      Goal is to remove these in a future change and make it simpler to adopt new SDK 
      drops

      https://github.com/dotnet/roslyn/issues/23547
    -->
    <AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
    <AppendRuntimeIdentifierToOutputPath>false</AppendRuntimeIdentifierToOutputPath>

    <!-- It is only intended to automatically run update during dev cycle. However, It will fail the build on CI if the XLF file is not updated.
         XLF file should be checked in and loc team will update the XLF it with translated version.
    -->
    <UpdateXlfOnBuild Condition="'$(DeveloperBuild)' == 'true'">true</UpdateXlfOnBuild>

    <!-- Even when we're using the "desktop" version of MSBuild we always want to use the "Core" approach for generating satellite assemblies.
         This avoids a couple of issues in al.exe (see https://github.com/dotnet/roslyn/issues/23190 and https://github.com/dotnet/roslyn/issues/23191
         for details on those issues). -->
    <GenerateSatelliteAssembliesForCore>true</GenerateSatelliteAssembliesForCore>

    <CustomBeforeMicrosoftCommonTargets>$(MSBuildThisFileDirectory)\BeforeCommonTargets.targets</CustomBeforeMicrosoftCommonTargets>
    <CustomAfterMicrosoftCommonTargets>$(MSBuildThisFileDirectory)\AfterCommonTargets.targets</CustomAfterMicrosoftCommonTargets>
  </PropertyGroup>

  <!-- Windows specific settings -->
  <PropertyGroup Condition="'$(OS)' == 'Windows_NT'">

    <!-- Presently our code can build on machines with Dev14 or Dev15 but only successfully deploy
         in the Dev15 environment.  -->
    <IsDev15RC Condition="Exists('$(MSBuildBinPath)\..\..\..\Common7\IDE\Microsoft.VisualStudio.ExtensionEngine.dll')">true</IsDev15RC>
    <IsDev15RC Condition="Exists('$(MSBuildBinPath)\..\..\..\..\Common7\IDE\Microsoft.VisualStudio.ExtensionEngine.dll')">true</IsDev15RC>
    <DeployExtension Condition="'$(IsDev15RC)' != 'true' OR '$(VisualStudioVersion)' != '15.0'">false</DeployExtension>
    <VisualStudioBuildToolsVersion>$(MicrosoftVSSDKBuildToolsVersion)</VisualStudioBuildToolsVersion>

    <!-- For the moment our Dev14 VSI suites must continue to use the Dev14 SDK. -->
    <VisualStudioBuildToolsVersion Condition="'$(IsDev14VsiBuild)' == 'true'">14.3.25420</VisualStudioBuildToolsVersion>
  </PropertyGroup>

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

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

  <!-- During bootstrap builds it's important to load our bootstrap tasks before doing any
       other imports (which could load a same named DLL) -->
  <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)' != ''" />
  <UsingTask TaskName="Microsoft.CodeAnalysis.BuildTasks.ValidateBootstrap"
             AssemblyFile="$(BootstrapBuildPath)\Microsoft.Build.Tasks.CodeAnalysis.dll"
             Condition="'$(BootstrapBuildPath)' != ''" />
  <UsingTask TaskName="Microsoft.CodeAnalysis.BuildTasks.CopyRefAssembly"
             AssemblyFile="$(BootstrapBuildPath)\Microsoft.Build.Tasks.CodeAnalysis.dll"
             Condition="'$(BootstrapBuildPath)' != ''" />
  <UsingTask TaskName="Roslyn.MSBuild.Util.FindNuGetAssetsForVsix"
             AssemblyFile="$(NuGetPackageRoot)\Roslyn.Build.Util\$(RoslynBuildUtilVersion)\lib\net46\Roslyn.MSBuild.Util.dll"
             Condition="'$(OS)' == 'Windows_NT'" />
  <UsingTask TaskName="Roslyn.MSBuild.Util.ValidateBuildEnvironment"
             AssemblyFile="$(NuGetPackageRoot)\Roslyn.Build.Util\$(RoslynBuildUtilVersion)\lib\net46\Roslyn.MSBuild.Util.dll"
             Condition="'$(OS)' == 'Windows_NT'" />

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

  <ImportGroup Label="WindowsImports" Condition="'$(OS)' == 'Windows_NT'">
    <Import 
      Project="$(NuGetPackageRoot)\Microsoft.VSSDK.BuildTools\$(VisualStudioBuildToolsVersion)\build\Microsoft.VsSDK.BuildTools.props"
      Condition="Exists('$(NuGetPackageRoot)\Microsoft.VSSDK.BuildTools\$(VisualStudioBuildToolsVersion)\build\Microsoft.VsSDK.BuildTools.props')" />
  </ImportGroup>

  <!-- 
    Temporarirly disable Toolset builds on Unix 

    https://github.com/dotnet/roslyn/issues/21725
   -->
  <Import Project="$(ToolsetCompilerPropsFilePath)" Condition="Exists('$(ToolsetCompilerPropsFilePath)') AND '$(BootstrapBuildPath)' == '' AND '$(OS)' == 'Windows_NT'" />

  <!--
      When building WPF projects MSBuild will create a temporary project with an extension of
      tmp_proj.  In that case the SDK is unable to determine the target language and cannot pick
      the correct import. Need to set it explicitly here.
      See https://github.com/dotnet/project-system/issues/1467
    -->
  <Choose>
    <When Condition="'$(MSBuildProjectExtension)' != '.csproj' and '$(MSBuildProjectExtension)' != '.vbproj' and '$(MSBuildProjectExtension)' != '.shproj'">
      <Choose>
        <When Condition="$(AssemblyName.Contains('Basic'))">
          <PropertyGroup>
            <Language>VB</Language>
            <LanguageTargets>$(MSBuildToolsPath)\Microsoft.VisualBasic.targets</LanguageTargets>
          </PropertyGroup>
        </When>
        <Otherwise>
          <PropertyGroup>
            <Language>C#</Language>
            <LanguageTargets>$(MSBuildToolsPath)\Microsoft.CSharp.targets</LanguageTargets>
          </PropertyGroup>
        </Otherwise>
      </Choose>
    </When>
  </Choose>

  <!-- 
    Language specifc settings 
    
    These deliberately come after importing the core targets. That way we can assure these are 
    the final settings, and not over written by core targets. Certain versions of the SDK for 
    example do exactly that.
    -->
  <Choose>
    <!-- VB specific settings -->
    <When Condition="'$(MSBuildProjectExtension)' == '.vbproj' OR '$(Language)' == 'VB' OR '$(ProjectLanguage)' == 'VisualBasic'">
      <PropertyGroup>
        <ProjectLanguage>VB</ProjectLanguage>
        <LangVersion>15.5</LangVersion>
        <MyType>Empty</MyType>
        <OptionCompare>Binary</OptionCompare>
        <OptionExplicit>On</OptionExplicit>
        <OptionInfer>On</OptionInfer>
        <OptionStrict>On</OptionStrict>
        <VBRuntime>Embed</VBRuntime>
        <RemoveIntegerChecks>true</RemoveIntegerChecks>
        <RootNamespace></RootNamespace>
        <MSBuildTargetsLanguageName>VisualBasic</MSBuildTargetsLanguageName>
        <NoWarn>$(NoWarn);40057</NoWarn>
      </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>
      <PropertyGroup>
        <DefineConstants Condition="'$(InitialDefineConstants)' != ''">$(InitialDefineConstants)</DefineConstants>
      </PropertyGroup>
    </When>

    <!-- C# specific settings -->
    <When Condition="'$(MSBuildProjectExtension)' == '.csproj' OR '$(Language)' == 'C#' OR '$(ProjectLanguage)' == 'CSharp'">
      <PropertyGroup>
        <ProjectLanguage>CSharp</ProjectLanguage>
        <LangVersion>7.2</LangVersion>
        <WarningLevel>4</WarningLevel>
        <ErrorReport>prompt</ErrorReport>

        <!-- Suppress the following warnings by default for C# projects
                1573: Suppressed in order to allow documentation for some but not all parameters.
                      A warning will still be reported if the documentation defines/references a
                      parameter which does not exist.
                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);1573;1591;1701</NoWarn>
        <CheckForOverflowUnderflow>false</CheckForOverflowUnderflow>
        <MSBuildTargetsLanguageName>CSharp</MSBuildTargetsLanguageName>
      </PropertyGroup>
      <PropertyGroup Condition="'$(Configuration)' == 'Debug'">
        <DebugSymbols>true</DebugSymbols>
        <DefineConstants>DEBUG;TRACE</DefineConstants>
      </PropertyGroup>
      <PropertyGroup Condition="'$(Configuration)' == 'Release'">
        <DefineConstants>TRACE</DefineConstants>
        <Optimize>true</Optimize>
      </PropertyGroup>
      <PropertyGroup>
        <DefineConstants Condition="'$(InitialDefineConstants)' != ''">$(DefineConstants);$(InitialDefineConstants)</DefineConstants>
      </PropertyGroup>
    </When>

    <!-- C++ specific settings -->
    <When Condition="'$(MSBuildProjectExtension)' == '.vcxproj' OR '$(Language)' == 'C++' OR '$(ProjectLanguage)' == 'C++'">
      <PropertyGroup>
        <ProjectLanguage>C++</ProjectLanguage>
        <!-- Put intermediate outputs in the same place as managed projects for sanity -->
        <IntDir>$(IntermediateOutputPath)</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>
    <DebugType>$(RoslynDebugType)</DebugType>
  </PropertyGroup>
</Project>