azure-pipelines-PR.yml

# CI and PR triggers
trigger:
  branches:
    include:
    - main
    - dev16.1
    - feature/*
    - release/*
  paths:
    include:
    - '*'
    exclude:
    - .github/*
    - docs/*
    - .vscode/*
    - .devcontainer/*
    - tests/scripts/*
    - attributions.md
    - CODE_OF_CONDUCT.md
    - DEVGUIDE.md
    - INTERNAL.md
    - Language-Version-History.md
    - License.txt
    - README.md
    - release-notes.md
    - TESTGUIDE.md

pr:
  branches:
    include:
    - main
    - dev16.1
    - feature/*
    - release/*
  paths:
    include:
    - '*'
    exclude:
    - .github/*
    - docs/*
    - attributions.md
    - CODE_OF_CONDUCT.md
    - DEVGUIDE.md
    - INTERNAL.md
    - Language-Version-History.md
    - License.txt
    - README.md
    - release-notes.md
    - TESTGUIDE.md

variables:
  - name: _TeamName
    value: FSharp
  - name: _BuildConfig
    value: Release
  - name: _PublishUsingPipelines
    value: true
  - name: VisualStudioDropName
    value: Products/$(System.TeamProject)/$(Build.Repository.Name)/$(Build.SourceBranchName)/$(Build.BuildNumber)
  - name: Codeql.Enabled
    value: true
  - ${{ if and(ne(variables['System.TeamProject'], 'public'), notin(variables['Build.Reason'], 'PullRequest')) }}:
    - group: DotNet-FSharp-SDLValidation-Params
  - ${{ if and(eq(variables['System.TeamProject'], 'public'), eq(variables['Build.Reason'], 'PullRequest')) }}:
    - name: RunningAsPullRequest
      value: true
  # Pick up pool provider name behavior from shared yaml template
  - template: /eng/common/templates/variables/pool-providers.yml

# Variables defined in yml cannot be overridden at queue time; instead overridable variables must be defined in the web UI.
# Commenting out until something like this is supported: https://github.com/Microsoft/azure-pipelines-yaml/pull/129
#variables:
#- name: SkipTests
#  defaultValue: false

stages:
- stage: build
  displayName: Build
  jobs:

  #-------------------------------------------------------------------------------------------------------------------#
  #                            PR builds without logs publishing                                                      #
  #-------------------------------------------------------------------------------------------------------------------#
  - ${{ if eq(variables['System.TeamProject'], 'public') }}:
    - template: /eng/common/templates/jobs/jobs.yml
      parameters:
        enableMicrobuild: false
        enablePublishBuildArtifacts: false
        enablePublishTestResults: false
        enablePublishBuildAssets: false
        enablePublishUsingPipelines: $(_PublishUsingPipelines)
        enableSourceBuild: false
        enableTelemetry: true
        helixRepo: dotnet/fsharp
        jobs:
          # Determinism, we want to run it only in PR builds
        - job: Determinism_Debug
          condition: eq(variables['Build.Reason'], 'PullRequest')
          variables:
          - name: _SignType
            value: Test
          pool:
            name: $(DncEngPublicBuildPool)
            demands: ImageOverride -equals $(WindowsMachineQueueName)
          timeoutInMinutes: 90
          strategy:
            maxParallel: 2
            matrix:
              regular:
                _experimental_flag: ''
              experimental_features:
                _experimental_flag: ''
          steps:
          - checkout: self
            clean: true
          # We first download a publicly available .NET SDK. That one has support for `path` in global.json. dotnet.cmd script can then download a version which is not yet shipped, but matches global.json.
          - task: UseDotNet@2
            displayName: install SDK
            inputs:
              packageType: sdk
              version: '10.x'
              includePreviewVersions: true
              workingDirectory: $(Build.SourcesDirectory)
              installationPath: $(Build.SourcesDirectory)/.dotnet
          - script: .\eng\common\dotnet.cmd
          - script: .\eng\test-determinism.cmd -configuration Debug
            env:
              FSHARP_EXPERIMENTAL_FEATURES: $(_experimental_flag)
            displayName: Determinism tests with Debug configuration
          - task: PublishPipelineArtifact@1
            displayName: Publish Determinism Logs
            inputs:
              targetPath: '$(Build.SourcesDirectory)/artifacts/log/Debug'
              artifactName: 'Determinism_Debug Attempt $(System.JobAttempt) Logs'
            continueOnError: true
            condition: not(succeeded())

          # Check FSComp.txt error code sorting and code formatting
        - job: CheckCodeFormatting
          pool:
            vmImage: $(UbuntuMachineQueueName)
          steps:
          - checkout: self
            clean: true
          - script: dotnet --list-sdks
            displayName: Report dotnet SDK versions

          - script: ./eng/common/dotnet.sh tool restore
            env:
              DOTNET_ROLL_FORWARD_TO_PRERELEASE: 1
            displayName: Install tools
          - script: ./eng/common/dotnet.sh fsi src/Compiler/FSCompCheck.fsx
            env:
              DOTNET_ROLL_FORWARD_TO_PRERELEASE: 1
            displayName: Check error code sorting in src/Compiler/FSComp.txt
          - script: ./eng/common/dotnet.sh fantomas . --check
            env:
              DOTNET_ROLL_FORWARD_TO_PRERELEASE: 1
            displayName: Check code formatting (run 'dotnet fantomas .' to fix)

        # Check whether package with current version has been published to nuget.org
        # We will try to restore both FSharp.Core and FCS and if restore is _successful_, package version needs to be bumped.
        # NOTE: The check now runs on all branches (not just release),
        #       because we want to catch cases when version is desynched and we didn't update it.
        #       It is also helping the release notes automation to be up to date with packages versions.
        - job: Check_Published_Package_Versions
          pool:
            vmImage: $(UbuntuMachineQueueName)
          strategy:
            maxParallel: 2
            matrix:
              FCS:
                _project: "FSharp.Compiler.Service_notshipped.fsproj"
              FSCore:
                _project: "FSharp.Core_notshipped.fsproj"
          steps:
          - checkout: self
            clean: true
          # We first download a publicly available .NET SDK. That one has support for `path` in global.json. dotnet.cmd script can then download a version which is not yet shipped, but matches global.json.
          - task: UseDotNet@2
            displayName: install SDK
            inputs:
              packageType: sdk
              version: '10.x'
              includePreviewVersions: true
              workingDirectory: $(Build.SourcesDirectory)
              installationPath: $(Build.SourcesDirectory)/.dotnet
          - script: ./eng/common/dotnet.sh
          - pwsh: ./check.ps1 -project $(_project)
            workingDirectory: $(Build.SourcesDirectory)/buildtools/checkpackages
            env:
                DOTNET_ROLL_FORWARD_TO_PRERELEASE: 1
            displayName: Check published package version


  #-------------------------------------------------------------------------------------------------------------------#
  #                                                    PR builds                                                      #
  #-------------------------------------------------------------------------------------------------------------------#
  - ${{ if eq(variables['System.TeamProject'], 'public') }}:
    - template: /eng/common/templates/jobs/jobs.yml
      parameters:
        enableMicrobuild: true
        enablePublishBuildArtifacts: true
        enablePublishTestResults: false
        enablePublishBuildAssets: true
        enablePublishUsingPipelines: $(_PublishUsingPipelines)
        enableSourceBuild: true
        sourceBuildParameters:
          platforms:
          - name: 'Managed'
            container: 'mcr.microsoft.com/dotnet-buildtools/prereqs:centos-stream9'
            buildArguments: '--source-build'
        enableTelemetry: true
        helixRepo: dotnet/fsharp
        jobs:

        - job: WindowsLangVersionPreview
          pool:
            # The PR build definition sets this variable:
            #   WindowsMachineQueueName=Windows.vs2022.amd64.open
            # and there is an alternate build definition that sets this to a queue that is always scouting the
            # next preview of Visual Studio.
            name: $(DncEngPublicBuildPool)
            demands: ImageOverride -equals $(WindowsMachineQueueName)
          timeoutInMinutes: 120
          steps:
          - checkout: self
            clean: true

          - script: eng\CIBuildNoPublish.cmd -compressallmetadata -configuration Release /p:FSharpLangVersion=preview
            env:
              DOTNET_DbgEnableMiniDump: 1
              DOTNET_DbgMiniDumpType: 3 # Triage dump, 1 for mini, 2 for Heap, 3 for triage, 4 for full. Don't use 4 unless you know what you're doing.
              DOTNET_DbgMiniDumpName: $(Build.SourcesDirectory)\artifacts\log\Release\$(Build.BuildId)-%e-%p-%t.dmp
              NativeToolsOnMachine: true
            displayName: Build

          - task: PublishBuildArtifacts@1
            displayName: Publish Build BinLog
            condition: always()
            continueOnError: true
            inputs:
                PathToPublish: '$(Build.SourcesDirectory)\artifacts\log/Release\Build.VisualFSharp.sln.binlog'
                ArtifactName: 'Windows Release build binlogs'
                ArtifactType: Container
                parallel: true
          - task: PublishBuildArtifacts@1
            displayName: Publish Dumps
            condition: failed()
            continueOnError: true
            inputs:
                PathToPublish: '$(Build.SourcesDirectory)\artifacts\log\Release'
                ArtifactName: 'Windows Release WindowsLangVersionPreview process dumps'
                ArtifactType: Container
                parallel: true

        - job: WindowsNoRealsig_testCoreclr
          pool:
            # The PR build definition sets this variable:
            #   WindowsMachineQueueName=Windows.vs2022.amd64.open
            # and there is an alternate build definition that sets this to a queue that is always scouting the
            # next preview of Visual Studio.
            name: $(DncEngPublicBuildPool)
            demands: ImageOverride -equals $(WindowsMachineQueueName)
          timeoutInMinutes: 120
          steps:
          - checkout: self
            clean: true

          - script: eng\CIBuildNoPublish.cmd -compressallmetadata -buildnorealsig -testCoreclr -configuration Release
            env:
              DOTNET_DbgEnableMiniDump: 1
              DOTNET_DbgMiniDumpType: 3 # Triage dump, 1 for mini, 2 for Heap, 3 for triage, 4 for full. Don't use 4 unless you know what you're doing.
              DOTNET_DbgMiniDumpName: $(Build.SourcesDirectory)\artifacts\log\Release\$(Build.BuildId)-%e-%p-%t.dmp
              NativeToolsOnMachine: true
            displayName: Build

          - task: PublishTestResults@2
            displayName: Publish Test Results
            inputs:
              testResultsFormat: 'XUnit'
              testRunTitle: WindowsNoRealsig_testCoreclr
              mergeTestResults: true
              testResultsFiles: '*.xml'
              searchFolder: '$(Build.SourcesDirectory)/artifacts/TestResults/Release'
            condition: succeededOrFailed()

          - task: PublishBuildArtifacts@1
            displayName: Publish Build BinLog
            condition: always()
            continueOnError: true
            inputs:
                PathToPublish: '$(Build.SourcesDirectory)\artifacts\log/Release\Build.VisualFSharp.sln.binlog'
                ArtifactName: 'Windows Release build binlogs'
                ArtifactType: Container
                parallel: true
          - task: PublishBuildArtifacts@1
            displayName: Publish Dumps
            condition: failed()
            continueOnError: true
            inputs:
                PathToPublish: '$(Build.SourcesDirectory)\artifacts\log\Release'
                ArtifactName: 'Windows Release WindowsNoRealsig_testCoreclr process dumps'
                ArtifactType: Container
                parallel: true

        - job: WindowsNoRealsig_testDesktop
          pool:
            # The PR build definition sets this variable:
            #   WindowsMachineQueueName=Windows.vs2022.amd64.open
            # and there is an alternate build definition that sets this to a queue that is always scouting the
            # next preview of Visual Studio.
            name: $(DncEngPublicBuildPool)
            demands: ImageOverride -equals $(WindowsMachineQueueName)
          timeoutInMinutes: 120
          strategy:
            parallel: 4
          steps:
          - checkout: self
            clean: true

          - script: eng\CIBuildNoPublish.cmd -compressallmetadata -buildnorealsig -testDesktop -configuration Release -testBatch $(System.JobPositionInPhase)
            env:
              DOTNET_DbgEnableMiniDump: 1
              DOTNET_DbgMiniDumpType: 3 # Triage dump, 1 for mini, 2 for Heap, 3 for triage, 4 for full. Don't use 4 unless you know what you're doing.
              DOTNET_DbgMiniDumpName: $(Build.SourcesDirectory)\artifacts\log\Release\$(Build.BuildId)-%e-%p-%t.dmp
              NativeToolsOnMachine: true
            displayName: Build

          - task: PublishTestResults@2
            displayName: Publish Test Results
            inputs:
              testResultsFormat: 'XUnit'
              testRunTitle: WindowsNoRealsig_testDesktop batch $(System.JobPositionInPhase)
              mergeTestResults: true
              testResultsFiles: '*.xml'
              searchFolder: '$(Build.SourcesDirectory)/artifacts/TestResults/Release'
            condition: succeededOrFailed()
            continueOnError: true
          - task: PublishBuildArtifacts@1
            displayName: Publish Build BinLog
            condition: eq(variables['System.JobPositionInPhase'], 1)
            continueOnError: true
            inputs:
                PathToPublish: '$(Build.SourcesDirectory)\artifacts\log/Release\Build.VisualFSharp.sln.binlog'
                ArtifactName: 'Windows Release build binlogs'
                ArtifactType: Container
                parallel: true
          - task: PublishBuildArtifacts@1
            displayName: Publish Dumps
            condition: failed()
            continueOnError: true
            inputs:
                PathToPublish: '$(Build.SourcesDirectory)\artifacts\log\Release'
                ArtifactName: 'Windows Release WindowsNoRealsig_testDesktop process dumps $(System.JobPositionInPhase)'
                ArtifactType: Container
                parallel: true

        - job: WindowsStrictIndentation
          pool:
            # The PR build definition sets this variable:
            #   WindowsMachineQueueName=Windows.vs2022.amd64.open
            # and there is an alternate build definition that sets this to a queue that is always scouting the
            # next preview of Visual Studio.
            name: $(DncEngPublicBuildPool)
            demands: ImageOverride -equals $(WindowsMachineQueueName)
          timeoutInMinutes: 120
          steps:
          - checkout: self
            clean: true

          - script: eng\CIBuildNoPublish.cmd -compressallmetadata -configuration Release /p:AdditionalFscCmdFlags=--strict-indentation+
            env:
              DOTNET_DbgEnableMiniDump: 1
              DOTNET_DbgMiniDumpType: 3 # Triage dump, 1 for mini, 2 for Heap, 3 for triage, 4 for full. Don't use 4 unless you know what you're doing.
              DOTNET_DbgMiniDumpName: $(Build.SourcesDirectory)\artifacts\log\Release\$(Build.BuildId)-%e-%p-%t.dmp
              NativeToolsOnMachine: true
            displayName: Build

          - task: PublishBuildArtifacts@1
            displayName: Publish Build BinLog
            condition: always()
            continueOnError: true
            inputs:
                PathToPublish: '$(Build.SourcesDirectory)\artifacts\log/Release\Build.VisualFSharp.sln.binlog'
                ArtifactName: 'Windows Release build binlogs'
                ArtifactType: Container
                parallel: true
          - task: PublishBuildArtifacts@1
            displayName: Publish Dumps
            condition: failed()
            continueOnError: true
            inputs:
                PathToPublish: '$(Build.SourcesDirectory)\artifacts\log\Release'
                ArtifactName: 'Windows Release WindowsStrictIndentation process dumps'
                ArtifactType: Container
                parallel: true

        - job: WindowsNoStrictIndentation
          pool:
            name: $(DncEngPublicBuildPool)
            demands: ImageOverride -equals $(WindowsMachineQueueName)
          timeoutInMinutes: 120
          steps:
          - checkout: self
            clean: true

          - script: eng\CIBuildNoPublish.cmd -compressallmetadata -configuration Release /p:AdditionalFscCmdFlags=--strict-indentation-
            env:
              DOTNET_DbgEnableMiniDump: 1
              DOTNET_DbgMiniDumpType: 3 # Triage dump, 1 for mini, 2 for Heap, 3 for triage, 4 for full. Don't use 4 unless you know what you're doing.
              DOTNET_DbgMiniDumpName: $(Build.SourcesDirectory)\artifacts\log\Release\$(Build.BuildId)-%e-%p-%t.dmp
              NativeToolsOnMachine: true
            displayName: Build

          - task: PublishBuildArtifacts@1
            displayName: Publish Build BinLog
            condition: always()
            continueOnError: true
            inputs:
                PathToPublish: '$(Build.SourcesDirectory)\artifacts\log/Release\Build.VisualFSharp.sln.binlog'
                ArtifactName: 'Windows Release build binlogs'
                ArtifactType: Container
                parallel: true
          - task: PublishBuildArtifacts@1
            displayName: Publish Dumps
            condition: failed()
            continueOnError: true
            inputs:
                PathToPublish: '$(Build.SourcesDirectory)\artifacts\log\Release'
                ArtifactName: 'Windows Release WindowsNoStrictIndentation process dumps'
                ArtifactType: Container
                parallel: true

        # Windows With Compressed Metadata
        - job: WindowsCompressedMetadata
          variables:
          - name: XUNIT_LOGS
            value: $(Build.SourcesDirectory)\artifacts\TestResults\$(_configuration)
          - name: __VSNeverShowWhatsNew
            value: 1
          pool:
            # The PR build definition sets this variable:
            #   WindowsMachineQueueName=Windows.vs2022.amd64.open
            # and there is an alternate build definition that sets this to a queue that is always scouting the
            # next preview of Visual Studio.
            name: $(DncEngPublicBuildPool)
            demands: ImageOverride -equals $(WindowsMachineQueueName)
          timeoutInMinutes: 120
          strategy:
            matrix:
              coreclr_release:
                _configuration: Release
                _testKind: testCoreclr
                transparentCompiler: # Empty display name part.
              fsharpqa_release:
                _configuration: Release
                _testKind: testFSharpQA
                transparentCompiler:
                FSHARP_CACHE_OVERRIDE: 256
              vs_release:
                _configuration: Release
                _testKind: testVs
                setupVsHive: true
                transparentCompiler:
                FSHARP_CACHE_OVERRIDE: 256
              transparent_compiler_release:
                _configuration: Release
                _testKind: testCoreclr
                TEST_TRANSPARENT_COMPILER: 1 # Pipeline variable will map to env var.
                transparentCompiler: TransparentCompiler
              # inttests_release:
              #   _configuration: Release
              #   _testKind: testIntegration
              #   setupVsHive: true
          steps:
          - checkout: self
            clean: true

          - powershell: eng\SetupVSHive.ps1
            displayName: Setup VS Hive
            condition: eq(variables.setupVsHive, 'true')

          - script: eng\CIBuildNoPublish.cmd -compressallmetadata -configuration $(_configuration) -$(_testKind)
            env:
              DOTNET_DbgEnableMiniDump: 1
              DOTNET_DbgMiniDumpType: 3 # Triage dump, 1 for mini, 2 for Heap, 3 for triage, 4 for full. Don't use 4 unless you know what you're doing.
              DOTNET_DbgMiniDumpName: $(Build.SourcesDirectory)\artifacts\log\$(_configuration)\$(Build.BuildId)-%e-%p-%t.dmp
              NativeToolsOnMachine: true
            displayName: Build and Test $(_testKind) $(transparentCompiler)

          - task: PublishTestResults@2
            displayName: Publish Test Results
            inputs:
              testResultsFormat: 'XUnit'
              testRunTitle: WindowsCompressedMetadata $(_testKind) $(transparentCompiler)
              mergeTestResults: true
              testResultsFiles: '*.xml'
              searchFolder: '$(Build.SourcesDirectory)/artifacts/TestResults/$(_configuration)'
            continueOnError: true
            condition: succeededOrFailed() # ne(variables['_testKind'], 'testFSharpQA')
          - task: PublishBuildArtifacts@1
            displayName: Publish Tests BinLog
            condition: always()
            continueOnError: true
            inputs:
                PathToPublish: '$(Build.SourcesDirectory)\artifacts\log/$(_configuration)\Build.VisualFSharp.sln.binlog'
                ArtifactName: Windows $(_configuration) $(_testKind) $(transparentCompiler) test binlogs
                ArtifactType: Container
                parallel: true
          - task: PublishBuildArtifacts@1
            displayName: Publish Dumps
            condition: failed()
            continueOnError: true
            inputs:
                PathToPublish: '$(Build.SourcesDirectory)\artifacts\log\$(_configuration)'
                ArtifactName: 'Windows $(_configuration) $(_testKind) process dumps'
                ArtifactType: Container
                parallel: true
          - task: PublishBuildArtifacts@1
            displayName: Publish Test Logs
            inputs:
              PathtoPublish: '$(Build.SourcesDirectory)\artifacts\TestResults\$(_configuration)'
              ArtifactName: Windows $(_configuration) $(_testKind) $(transparentCompilerSuffix) test logs
              publishLocation: Container
            continueOnError: true
            condition: always()
          - script: dotnet build $(Build.SourcesDirectory)/eng/DumpPackageRoot/DumpPackageRoot.csproj
            displayName: Dump NuGet cache contents
            condition: failed()
          - task: PublishBuildArtifacts@1
            displayName: Publish NuGet cache contents
            inputs:
              PathtoPublish: '$(Build.SourcesDirectory)\artifacts\NugetPackageRootContents'
              ArtifactName: 'NuGetPackageContents Windows $(_testKind)'
              publishLocation: Container
            continueOnError: true
            condition: failed()

          # Windows With Compressed Metadata Desktop
        - job: WindowsCompressedMetadata_Desktop
          variables:
          - name: XUNIT_LOGS
            value: $(Build.SourcesDirectory)\artifacts\TestResults\Release
          - name: __VSNeverShowWhatsNew
            value: 1
          pool:
            # The PR build definition sets this variable:
            #   WindowsMachineQueueName=Windows.vs2022.amd64.open
            # and there is an alternate build definition that sets this to a queue that is always scouting the
            # next preview of Visual Studio.
            name: $(DncEngPublicBuildPool)
            demands: ImageOverride -equals $(WindowsMachineQueueName)
          timeoutInMinutes: 120
          strategy:
            parallel: 4

          steps:
          - checkout: self
            clean: true

          - script: eng\CIBuildNoPublish.cmd -compressallmetadata -configuration Release -testDesktop -testBatch $(System.JobPositionInPhase)
            env:
              DOTNET_DbgEnableMiniDump: 1
              DOTNET_DbgMiniDumpType: 3 # Triage dump, 1 for mini, 2 for Heap, 3 for triage, 4 for full. Don't use 4 unless you know what you're doing.
              DOTNET_DbgMiniDumpName: $(Build.SourcesDirectory)\artifacts\log\Release\$(Build.BuildId)-%e-%p-%t.dmp
              NativeToolsOnMachine: true
            displayName: Build / Test

          - task: PublishTestResults@2
            displayName: Publish Test Results
            inputs:
              testResultsFormat: 'XUnit'
              testRunTitle: WindowsCompressedMetadata testDesktop batch $(System.JobPositionInPhase)
              mergeTestResults: true
              testResultsFiles: '*.xml'
              searchFolder: '$(Build.SourcesDirectory)/artifacts/TestResults/Release'
            continueOnError: true
            condition: succeededOrFailed()

          - task: PublishBuildArtifacts@1
            displayName: Publish BinLog
            condition: eq(variables['System.JobPositionInPhase'], 1)
            continueOnError: true
            inputs:
                PathToPublish: '$(Build.SourcesDirectory)\artifacts\log/Release\Build.VisualFSharp.sln.binlog'
                ArtifactName: 'Windows testDesktop binlogs'
                ArtifactType: Container
                parallel: true
          - task: PublishBuildArtifacts@1
            displayName: Publish Dumps
            condition: failed()
            continueOnError: true
            inputs:
                PathToPublish: '$(Build.SourcesDirectory)\artifacts\log\Release'
                ArtifactName: 'Windows testDesktop process dumps $(System.JobPositionInPhase)'
                ArtifactType: Container
                parallel: true
          - task: PublishBuildArtifacts@1
            displayName: Publish Test Logs
            inputs:
              PathtoPublish: '$(Build.SourcesDirectory)\artifacts\TestResults\Release'
              ArtifactName: 'Windows testDesktop test logs batch $(System.JobPositionInPhase)'
              publishLocation: Container
            continueOnError: true
            condition: always()
          - script: dotnet build $(Build.SourcesDirectory)/eng/DumpPackageRoot/DumpPackageRoot.csproj
            displayName: Dump NuGet cache contents
            condition: failed()
          - task: PublishBuildArtifacts@1
            displayName: Publish NuGet cache contents
            inputs:
              PathtoPublish: '$(Build.SourcesDirectory)\artifacts\NugetPackageRootContents'
              ArtifactName: 'NuGetPackageContents Windows testDesktop $(System.JobPositionInPhase)'
              publishLocation: Container
            continueOnError: true
            condition: failed()

        # Mock official build
        - job: MockOfficial
          pool:
            name: $(DncEngPublicBuildPool)
            demands: ImageOverride -equals $(WindowsMachineQueueName)
          steps:
          - checkout: self
            clean: true
          - pwsh: .\eng\MockBuild.ps1
            displayName: Build with OfficialBuildId

        # Linux
        - job: Linux
          pool:
            vmImage: $(UbuntuMachineQueueName)
          timeoutInMinutes: 120
          variables:
          - name: _SignType
            value: Test
          steps:
          - checkout: self
            clean: true
          - script: ./eng/cibuild.sh --configuration $(_BuildConfig) --testcoreclr
            displayName: Build / Test
          - task: PublishTestResults@2
            displayName: Publish Test Results
            inputs:
              testResultsFormat: 'XUnit'
              testRunTitle: Linux
              testResultsFiles: '*.xml'
              mergeTestResults: true
              searchFolder: '$(Build.SourcesDirectory)/artifacts/TestResults/$(_BuildConfig)'
            continueOnError: true
            condition: succeededOrFailed()
          - task: PublishBuildArtifacts@1
            displayName: Publish Test Logs
            inputs:
              PathtoPublish: '$(Build.SourcesDirectory)/artifacts/TestResults/$(_BuildConfig)'
              ArtifactName: 'Linux $(_BuildConfig) test logs'
              publishLocation: Container
            continueOnError: true
            condition: failed()
          - script: dotnet build $(Build.SourcesDirectory)/eng/DumpPackageRoot/DumpPackageRoot.csproj
            displayName: Dump NuGet cache contents
            condition: failed()
          - task: PublishBuildArtifacts@1
            displayName: Publish NuGet cache contents
            inputs:
              PathtoPublish: '$(Build.SourcesDirectory)/artifacts/NugetPackageRootContents'
              ArtifactName: 'NuGetPackageContents Linux'
              publishLocation: Container
            continueOnError: true
            condition: failed()

        # MacOS
        - job: MacOS
          pool:
            vmImage: macos-latest
          timeoutInMinutes: 120
          variables:
          - name: _SignType
            value: Test
          steps:
          - checkout: self
            clean: true
          - script: ./eng/cibuild.sh --configuration $(_BuildConfig) --testcoreclr
            env:
              COMPlus_DefaultStackSize: 1000000
            displayName: Build / Test
          - task: PublishTestResults@2
            displayName: Publish Test Results
            inputs:
              testResultsFormat: 'XUnit'
              testResultsFiles: '*.xml'
              testRunTitle: MacOS
              mergeTestResults: true
              searchFolder: '$(Build.SourcesDirectory)/artifacts/TestResults/$(_BuildConfig)'
            continueOnError: true
            condition: succeededOrFailed()
          - task: PublishBuildArtifacts@1
            displayName: Publish Test Logs
            inputs:
              PathtoPublish: '$(Build.SourcesDirectory)/artifacts/TestResults/$(_BuildConfig)'
              ArtifactName: 'MacOS $(_BuildConfig) test logs'
              publishLocation: Container
            continueOnError: true
            condition: failed()
          - script: dotnet build $(Build.SourcesDirectory)/eng/DumpPackageRoot/DumpPackageRoot.csproj
            displayName: Dump NuGet cache contents
            condition: failed()
          - task: PublishBuildArtifacts@1
            displayName: Publish NuGet cache contents
            inputs:
              PathtoPublish: '$(Build.SourcesDirectory)/artifacts/NugetPackageRootContents'
              ArtifactName: 'NuGetPackageContents Mac'
              publishLocation: Container
            continueOnError: true
            condition: failed()

        # End to end build
        - job: EndToEndBuildTests
          pool:
            name: $(DncEngPublicBuildPool)
            demands: ImageOverride -equals $(WindowsMachineQueueName)
          strategy:
            maxParallel: 2
            matrix:
              regular:
                _experimental_flag: ''
              experimental_features:
                _experimental_flag: ''
          steps:
          - checkout: self
            clean: true
          - script: .\Build.cmd -c Release -pack
            env:
              NativeToolsOnMachine: true
              FSHARP_EXPERIMENTAL_FEATURES: $(_experimental_flag)
          - script: .\tests\EndToEndBuildTests\EndToEndBuildTests.cmd -c Release
            env:
              FSHARP_EXPERIMENTAL_FEATURES: $(_experimental_flag)
            displayName: End to end build tests

        # Up-to-date - disabled due to it being flaky
        #- job: UpToDate_Windows
        #  pool:
        #    vmImage: windows-latest
        #  steps:
        #  - checkout: self
        #    clean: true
        #  - task: PowerShell@2
        #    displayName: Run up-to-date build check
        #    inputs:
        #      filePath: eng\tests\UpToDate.ps1
        #      arguments: -configuration $(_BuildConfig) -ci -binaryLog

        # Run Build with Fsharp Experimental Features
        # Possible change: --times:$(Build.SourcesDirectory)/artifacts/log/Release/compiler_timing.csv

        # Plain FCS build Windows
        - job: Plain_Build_Windows
          pool:
            name: $(DncEngPublicBuildPool)
            demands: ImageOverride -equals $(WindowsMachineQueueName)
          variables:
          - name: _BuildConfig
            value: Debug
          steps:
          - checkout: self
            clean: true
          - script: dotnet --list-sdks
            displayName: Report dotnet SDK versions
          - script: .\eng\common\dotnet.cmd build .\FSharp.Compiler.Service.sln /bl:\"artifacts/log/$(_BuildConfig)/ServiceRegularBuild.binlog\"
            workingDirectory: $(Build.SourcesDirectory)
            displayName: Regular rebuild of FSharp.Compiler.Service.sln
            continueOnError: false
            condition: always()

        # Plain FCS build Linux
        - job: Plain_Build_Linux
          pool:
            vmImage: $(UbuntuMachineQueueName)
          variables:
          - name: _BuildConfig
            value: Debug
          steps:
          - checkout: self
            clean: true
          - script: dotnet --list-sdks
            displayName: Report dotnet SDK versions
          - script: ./eng/common/dotnet.sh build ./FSharp.Compiler.Service.sln /bl:\"artifacts/log/$(_BuildConfig)/ServiceRegularBuild.binlog\"
            workingDirectory: $(Build.SourcesDirectory)
            displayName: Regular rebuild of FSharp.Compiler.Service.sln
            continueOnError: false
            condition: always()

        # Plain FCS build Mac
        - job: Plain_Build_MacOS
          pool:
            vmImage: macos-latest
          variables:
          - name: _BuildConfig
            value: Debug
          steps:
          - checkout: self
            clean: true
          - script: dotnet --list-sdks
            displayName: Report dotnet SDK versions
          - script: ./eng/common/dotnet.sh build ./FSharp.Compiler.Service.sln /bl:\"artifacts/log/$(_BuildConfig)/ServiceRegularBuild.binlog\"
            workingDirectory: $(Build.SourcesDirectory)
            displayName: Regular rebuild of FSharp.Compiler.Service.sln
            continueOnError: false
            condition: always()

        # Build and run fast benchmarks
        - job: Benchmarks
          pool:
            name: $(DncEngPublicBuildPool)
            demands: ImageOverride -equals $(WindowsMachineQueueName)
          variables:
          - name: _BuildConfig
            value: Release
          steps:
          - checkout: self
            clean: true
          - script: eng\CIBuild.cmd -configuration $(_BuildConfig) -testBenchmarks
            displayName: Smoke test fast benchmarks
            continueOnError: true
            condition: always()

        # Test trimming on Windows
        - job: Build_And_Test_AOT_Windows
          pool:
            name: $(DncEngPublicBuildPool)
            demands: ImageOverride -equals $(WindowsMachineQueueName)
          strategy:
            maxParallel: 2
            matrix:
              compressed_metadata:
                _kind: "-compressAllMetadata"
              classic_metadata:
                _kind: ""
          variables:
          - name: _BuildConfig
            value: Release
          steps:
          - checkout: self
            clean: true
          # We first download a publicly available .NET SDK. That one has support for `path` in global.json. dotnet.cmd script can then download a version which is not yet shipped, but matches global.json.
          - task: UseDotNet@2
            displayName: install SDK
            inputs:
              packageType: sdk
              version: '10.x'
              includePreviewVersions: true
              workingDirectory: $(Build.SourcesDirectory)
              installationPath: $(Build.SourcesDirectory)/.dotnet
          - script: .\eng\common\dotnet.cmd
          - script: .\Build.cmd $(_kind) -pack -c $(_BuildConfig)
            env:
              NativeToolsOnMachine: true
            displayName: Initial build and prepare packages.
          - powershell: $(Build.SourcesDirectory)/tests/AheadOfTime/check.ps1
            displayName: Build, trim, publish and check the state of the trimmed app.
            workingDirectory: $(Build.SourcesDirectory)/tests/AheadOfTime
          - task: PublishPipelineArtifact@1
            displayName: Publish Trim Tests Logs
            inputs:
              targetPath: './artifacts/log/Release/AheadOfTime/Trimming/'
              artifactName: 'Trim Test Logs Attempt $(System.JobAttempt) Logs $(_kind)'
            continueOnError: true
            condition: always()
        - job: ILVerify
          pool:
            name: $(DncEngPublicBuildPool)
            demands: ImageOverride -equals $(WindowsMachineQueueName)
          steps:
          - checkout: self
            clean: true
          # We first download a publicly available .NET SDK. That one has support for `path` in global.json. dotnet.cmd script can then download a version which is not yet shipped, but matches global.json.
          - task: UseDotNet@2
            displayName: install SDK
            inputs:
              packageType: sdk
              version: '10.x'
              includePreviewVersions: true
              workingDirectory: $(Build.SourcesDirectory)
              installationPath: $(Build.SourcesDirectory)/.dotnet
          - script: .\eng\common\dotnet.cmd
          - script: dotnet tool restore
            displayName: Restore dotnet tools
          - pwsh: .\tests\ILVerify\ilverify.ps1
            displayName: Run ILVerify
            workingDirectory: $(Build.SourcesDirectory)